home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / cap / tools / interp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  84.6 KB  |  3,075 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. /*
  19.  *    Kurt Akeley
  20.  *    26 January 1988
  21.  *
  22.  *    Simple GL interpreter
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include <awk.h>
  27. #include <gl/gl.h>
  28. #include "interp.h"
  29.  
  30. #define INFINITY (1000000000)
  31. #define MAXVCOUNT 100
  32.  
  33. static float xmin =  INFINITY;
  34. static float xmax = -INFINITY;
  35. static float ymin =  INFINITY;
  36. static float ymax = -INFINITY;
  37. static float zmin =  INFINITY;
  38. static float zmax = -INFINITY;
  39. static long vcount = 0;
  40. static int breakok = TRUE;        /* mode during list generation */
  41.  
  42. static void (*breakfunction)() = 0;    /* call back at MAXVCOUNT intervals */
  43.  
  44. AwkArray* CommandNumber;
  45. AwkArray* Constant;
  46. AwkArray* ImagePointer;
  47. AwkArray* FilePointers;
  48.  
  49. /*
  50.  *    Variables and functions to support groups of vertexes
  51.  *
  52.  *    Note - some of the code here is rather complex (especially the
  53.  *        support for hollow polygons).  It can generally be ignored.
  54.  */
  55.  
  56. static void (*bgnfunc)();
  57. static void (*endfunc)();
  58. static void (*compfunc)();
  59. static void (*compfunc2)();
  60. static int grptype;
  61.  
  62. static void interp_bgngroup(int* data) {
  63.     (*bgnfunc)(data);
  64. }
  65.  
  66. static void interp_endgroup(void) {
  67.     (*endfunc)();
  68. }
  69.  
  70.  
  71. static element_t *hollow_savejump;
  72. static element_t **hollow_savepointer;
  73. static long hollowcolor = 0xffffff;
  74. static long hollowwidth = 2;
  75.  
  76. #define ZMASK 0x800000
  77. #define ZVAL_ENABLE 0
  78. #define ZVAL_DISABLE 0x800000
  79.  
  80. static void bgnhollowpoly(data) int *data; {
  81.     register element_t* sp;
  82.  
  83.     /* set sp to pointer to next element */
  84.     sp = (element_t*) *(data-1);
  85.  
  86.     /* save pointer to next element */
  87.     hollow_savejump = sp;
  88.     hollow_savepointer = (element_t**)(data-1);
  89.  
  90.     /*
  91.      *    First disable all the pixels in the polygon.  Do this by changing
  92.      *    a single bit in the Z-buffer.
  93.      */
  94.  
  95.     zbuffer(FALSE);
  96.     backbuffer(FALSE);
  97.     zdraw(TRUE);
  98.     wmpack(ZMASK);
  99.     cpack(ZVAL_DISABLE);
  100.     compfunc = interp_endgroup;
  101.     compfunc2 = v3f;
  102.     bgnpolygon();
  103.     for (sp=hollow_savejump; (sp->func) != compfunc; sp = sp->next) {
  104.     if ((sp->func) == compfunc2)
  105.         sp->func((float*)sp+NONDATASIZE);
  106.     }
  107.     endpolygon();
  108.  
  109.     /*
  110.      *    Now enable only the pixels on the outline of the polygon
  111.      *    for filling.  Do this by changing a single Z-buffer bit back.
  112.      */
  113.  
  114.     cpack(ZVAL_ENABLE);
  115.     linewidth(hollowwidth);
  116.     bgnclosedline();
  117.     for (sp=hollow_savejump; (sp->func) != compfunc; sp = sp->next) {
  118.     if ((sp->func) == compfunc2)
  119.         sp->func((float*)sp+NONDATASIZE);
  120.     }
  121.     endclosedline();
  122.     linewidth(1);
  123.  
  124.     /*
  125.      *    Now fill the polygon using its color commands
  126.      */
  127.  
  128.     zbuffer(TRUE);
  129.     backbuffer(TRUE);
  130.     zdraw(FALSE);
  131.     wmpack(0xffffff);
  132.     cpack(hollowcolor);
  133.     bgnpolygon();
  134.     for (sp=hollow_savejump; (sp->func) != compfunc; sp = sp->next) {
  135.     sp->func((float*)sp+NONDATASIZE);
  136.     }
  137.     endpolygon();
  138.  
  139.     /*
  140.      *    Now enable all the pixels in the polygon
  141.      */
  142.  
  143.     zbuffer(FALSE);
  144.     backbuffer(FALSE);
  145.     zdraw(TRUE);
  146.     wmpack(ZMASK);
  147.     cpack(ZVAL_ENABLE);
  148.     bgnpolygon();
  149.     for (sp=hollow_savejump; (sp->func) != compfunc; sp = sp->next) {
  150.     if ((sp->func) == compfunc2)
  151.         sp->func((float*)sp+NONDATASIZE);
  152.     }
  153.     endpolygon();
  154.  
  155.     /*
  156.      *    Now cleanup the mess we've made of the machine state
  157.      */
  158.  
  159.     zbuffer(TRUE);
  160.     backbuffer(TRUE);
  161.     zdraw(FALSE);
  162.     wmpack(0xffffffff);
  163.  
  164.     /* change next pointer to point to endgroup command */
  165.     *hollow_savepointer = sp;
  166. }
  167.  
  168. static void endhollowpoly(void) {
  169.     /* normal traversal has now jumped here - fix up bgngroup pointer */
  170.     *hollow_savepointer = hollow_savejump;
  171. }
  172.  
  173. int getgrouptype(void) {
  174.     return grptype;
  175. }
  176.  
  177. void grouptype(int type) {
  178.     grptype = type;
  179.     switch (type) {
  180.     case GRP_POINT:
  181.         bgnfunc = bgnpoint;
  182.         endfunc = endpoint;
  183.         break;
  184.     case GRP_LINE:
  185.         bgnfunc = bgnline;
  186.         endfunc = endline;
  187.         break;
  188.     case GRP_CLOSEDLINE:
  189.         bgnfunc = bgnclosedline;
  190.         endfunc = endclosedline;
  191.         break;
  192.     case GRP_POLYGON:
  193.         bgnfunc = bgnpolygon;
  194.         endfunc = endpolygon;
  195.         break;
  196.     case GRP_TMESH:
  197.         bgnfunc = bgntmesh;
  198.         endfunc = endtmesh;
  199.         break;
  200.     case GRP_HOLLOWPOLY:
  201.         bgnfunc = bgnhollowpoly;
  202.         endfunc = endhollowpoly;
  203.         break;
  204.     }
  205. }
  206.  
  207. static void interp_grouptype(int* data) {
  208.     grouptype(data[0]);
  209. }
  210.  
  211. static void interp_hollowcolor(int* data) {
  212.     hollowcolor = data[0];
  213. }
  214.  
  215. static void interp_hollowwidth(int* data) {
  216.     hollowwidth = data[0];
  217. }
  218.  
  219. /*
  220.  *    Wrapper functions for GL commands that do not take a single
  221.  *    pointer to data.
  222.  */
  223.  
  224. static void interp_acbuf(float* data) {
  225.     acbuf((long)data[0],data[1]);
  226. }
  227.  
  228. static void interp_acsize(int* data) {
  229.     acsize(data[0]);
  230. }
  231.  
  232. static void interp_afunction(int* data) {
  233.     afunction(data[0],data[1]);
  234. }
  235.  
  236. static void interp_arc(float* data) {
  237.     arc(data[0],data[1],(int)data[2],(int)data[3],(int)data[4]);
  238. }
  239.  
  240. static void interp_arcf(float* data) {
  241.     arcf(data[0],data[1],(int)data[2],(int)data[3],(int)data[4]);
  242. }
  243.  
  244. static void interp_backbuffer(int* data) {
  245.     backbuffer(data[0]);
  246. }
  247.  
  248. static void interp_backface(int* data) {
  249.     backface(data[0]);
  250. }
  251.  
  252. static void interp_blendfunction(int* data) {
  253.     blendfunction(data[0],data[1]);
  254. }
  255.  
  256. static void interp_blink(int* data) {
  257.     blink(data[0],data[1],data[2],data[3],data[4]);
  258. }
  259.  
  260. #define IND(d,i) &(d[(i)*4])
  261.  
  262. static void interp_box(float* data) {
  263.     static float n[24] = {
  264.      1, 0, 0, 0,
  265.     -1, 0, 0, 0,
  266.      0, 1, 0, 0,
  267.      0,-1, 0, 0,
  268.      0, 0, 1, 0,
  269.      0, 0,-1, 0,
  270.     };
  271.     bgnpolygon();
  272.     n3f(IND(n,5));
  273.     v3f(IND(data,0));
  274.     v3f(IND(data,2));
  275.     v3f(IND(data,3));
  276.     v3f(IND(data,1));
  277.     endpolygon();
  278.     bgnpolygon();
  279.     n3f(IND(n,0));
  280.     v3f(IND(data,1));
  281.     v3f(IND(data,3));
  282.     v3f(IND(data,7));
  283.     v3f(IND(data,5));
  284.     endpolygon();
  285.     bgnpolygon();
  286.     n3f(IND(n,4));
  287.     v3f(IND(data,5));
  288.     v3f(IND(data,7));
  289.     v3f(IND(data,6));
  290.     v3f(IND(data,4));
  291.     endpolygon();
  292.     bgnpolygon();
  293.     n3f(IND(n,1));
  294.     v3f(IND(data,4));
  295.     v3f(IND(data,6));
  296.     v3f(IND(data,2));
  297.     v3f(IND(data,0));
  298.     endpolygon();
  299.     bgnpolygon();
  300.     n3f(IND(n,2));
  301.     v3f(IND(data,6));
  302.     v3f(IND(data,7));
  303.     v3f(IND(data,3));
  304.     v3f(IND(data,2));
  305.     endpolygon();
  306.     bgnpolygon();
  307.     n3f(IND(n,3));
  308.     v3f(IND(data,0));
  309.     v3f(IND(data,1));
  310.     v3f(IND(data,5));
  311.     v3f(IND(data,4));
  312.     endpolygon();
  313. }
  314.  
  315. static void interp_breakcheck() {
  316.     if (breakfunction)
  317.     (*breakfunction)();
  318. }
  319.  
  320. static void interp_callobj(int* data) {
  321.     register char* s;
  322.     register int i;
  323.     if (data[0])
  324.     drawinterpobj((element_t*)data[0]);
  325.     else {
  326.     s = (char*) &data[1];
  327.     if (i = (int)awkGetPointer(FilePointers,s)) {
  328.         data[0] = i;
  329.         drawinterpobj((element_t*)data[0]);
  330.         return;
  331.     }
  332.     fprintf(stderr,"reading sub-object <%s> ... ",s);
  333.     if (i = (int)getinterpobj(s)) {
  334.         fprintf(stderr,"done\n");
  335.         data[0] = i;
  336.         drawinterpobj((element_t*)data[0]);
  337.         return;
  338.     }
  339.     else {
  340.         fprintf(stderr,"failed.  abort.\n",s);
  341.         exit(1);
  342.     }
  343.     }
  344. }
  345.  
  346. static void interp_charstr(char* data) {
  347.     charstr(data);
  348. }
  349.  
  350. static void interp_circ(float* data) {
  351.     circ(data[0],data[1],(int)data[2]);
  352. }
  353.  
  354. static void interp_circf(float* data) {
  355.     circf(data[0],data[1],(int)data[2]);
  356. }
  357.  
  358. static void interp_clipplane(float* data) {
  359.     clipplane((long)data[0],(long)data[1],&data[2]);
  360. }
  361.  
  362. static void interp_cmov(float* data) {
  363.     cmov(data[0],data[1],data[2]);
  364. }
  365.  
  366. static void interp_color(int* data) {
  367.     color(data[0]);
  368. }
  369.  
  370. static void interp_colorf(float* data) {
  371.     colorf(data[0]);
  372. }
  373.  
  374. static void interp_cpack(int* data) {
  375.     cpack(data[0]);
  376. }
  377.  
  378. static void interp_concave(int* data) {
  379.     concave(data[0]);
  380. }
  381.  
  382. static void interp_czclear(int* data) {
  383.     czclear(data[0],data[1]);
  384. }
  385.  
  386. static void interp_deflinestyle(int* data) {
  387.     deflinestyle(data[0],data[1]);
  388. }
  389.  
  390. static void interp_defpattern(unsigned int* data) {
  391.     unsigned short mask[64];
  392.     int size;
  393.     int i;
  394.     i = data[1];
  395.     size = i * (i>>4);
  396.     for (i=0; i<size; i++)
  397.     mask[i] = data[i+2];
  398.     defpattern(data[0],data[1],mask);
  399. }
  400.  
  401. static void interp_displacepolygon(float* data) {
  402. #ifdef GD_TEXTURE_3D
  403.     displacepolygon(data[0]);
  404. #endif
  405. }
  406.  
  407. static void interp_depthcue(int* data) {
  408.     depthcue(data[0]);
  409. }
  410.  
  411. static void interp_draw(float* data) {
  412.     draw(data[0],data[1],data[2]);
  413. }
  414.  
  415. static void interp_drawmode(int* data) {
  416.     drawmode(data[0]);
  417. }
  418.  
  419. static void interp_fogvertex(float* data) {
  420.     fogvertex((long)data[0],&data[1]);
  421. }
  422.  
  423. static void interp_frontbuffer(int* data) {
  424.     frontbuffer(data[0]);
  425. }
  426.  
  427. static void interp_frontface(int* data) {
  428.     frontface(data[0]);
  429. }
  430.  
  431. static void interp_glcompat(int* data) {
  432.     glcompat(data[0],data[1]);
  433. }
  434.  
  435. static void interp_linesmooth(int* data) {
  436.     linesmooth(data[0]);
  437. }
  438.  
  439. static void interp_linewidth(int* data) {
  440.     linewidth(data[0]);
  441. }
  442.  
  443. static void interp_lmbind(int* data) {
  444.     lmbind(data[0],data[1]);
  445. }
  446.  
  447. static void interp_lmcolor(int* data) {
  448.     lmcolor(data[0]);
  449. }
  450.  
  451. static void interp_lmdef(float* data) {
  452.     int target,index,size;
  453.     target = (int)data[0];
  454.     index = (int)data[1];
  455.     size = (int)data[2];
  456.     lmdef(target,index,size,data+3);
  457. }
  458.  
  459. static void interp_logicop(int* data) {
  460.     logicop(data[0]);
  461. }
  462.  
  463. static void interp_lookat(float* data) {
  464.     int twist;
  465.     twist = (int)data[6];
  466.     lookat(data[0],data[1],data[2],data[3],data[4],data[5],twist);
  467. }
  468.  
  469. static void interp_lrectwrite(int* data) {
  470.     lrectwrite(data[0],data[1],data[2],data[3],(unsigned long*)data[4]);
  471. }
  472.  
  473. static void interp_lrgbrange(int* data) {
  474.     lRGBrange(data[0],data[1],data[2],data[3],data[4],data[5],data[6],data[7]);
  475. }
  476.  
  477. static void interp_lsetdepth(int* data) {
  478.     lsetdepth(data[0],data[1]);
  479. }
  480.  
  481. static void interp_lshaderange(int* data) {
  482.     lshaderange(data[0],data[1],data[2],data[3]);
  483. }
  484.  
  485. static void interp_lsrepeat(int* data) {
  486.     lsrepeat(data[0]);
  487. }
  488.  
  489. static void interp_mapcolor(int* data) {
  490.     mapcolor(data[0],data[1],data[2],data[3]);
  491. }
  492.  
  493. static void interp_mmode(int* data) {
  494.     mmode(data[0]);
  495. }
  496.  
  497. static void interp_move(float* data) {
  498.     move(data[0],data[1],data[2]);
  499. }
  500.  
  501. static void interp_mswapbuffers(int* data) {
  502.     mswapbuffers(data[0]);
  503. }
  504.  
  505. static void interp_nmode(int* data) {
  506.     nmode(data[0]);
  507. }
  508.  
  509. static void interp_ortho(float* data) {
  510.     ortho(data[0],data[1],data[2],data[3],data[4],data[5]);
  511. }
  512.  
  513. static void interp_ortho2(float* data) {
  514.     ortho2(data[0],data[1],data[2],data[3]);
  515. }
  516.  
  517. static void interp_overlay(int* data) {
  518.     overlay(data[0]);
  519. }
  520.  
  521. static void interp_pdr(float* data) {
  522.     pdr(data[0],data[1],data[2]);
  523. }
  524.  
  525. static void interp_perspective(float* data) {
  526.     int fovy;
  527.     fovy = (int)data[0];
  528.     perspective(fovy,data[1],data[2],data[3]);
  529. }
  530.  
  531. static void interp_pixmode(int* data) {
  532.     pixmode(data[0],data[1]);
  533. }
  534.  
  535. static void interp_pmv(float* data) {
  536.     pmv(data[0],data[1],data[2]);
  537. }
  538.  
  539. static void interp_pnt(float* data) {
  540.     pnt(data[0],data[1],data[2]);
  541. }
  542.  
  543. static void interp_pntsize(float* data) {
  544.     pntsize(data[0]);
  545. }
  546.  
  547. static void interp_pntsmooth(int* data) {
  548.     pntsmooth(data[0]);
  549. }
  550.  
  551. static void interp_polarview(float* data) {
  552.     int azim,inc,twist;
  553.     azim = (int)data[1];
  554.     inc = (int)data[2];
  555.     twist = (int)data[3];
  556.     polarview(data[0],azim,inc,twist);
  557. }
  558.  
  559. #define MAXPOLY 100
  560.  
  561. static void interp_polf(float* data) {
  562. #ifdef NOTDEF
  563.     Coord polfdata[MAXPOLY][3];
  564.     long n;
  565.     int i;
  566.     n = data[0];
  567.     if (n >= MAXPOLY)
  568.     n = MAXPOLY;
  569.     for (i=0; i < n; i++) {
  570.     polfdata[i][0] = data[3*i+1];
  571.     polfdata[i][1] = data[3*i+2];
  572.     polfdata[i][2] = data[3*i+3];
  573.     }
  574.     polf(n, polfdata);
  575. #else
  576.     fprintf(stderr, "polf is broken, the #$*& compiler won't deal with it!\n");
  577. #endif
  578. }
  579.  
  580. static void interp_poly(float* data) {
  581. #ifdef NOTDEF
  582.     Coord polydata[MAXPOLY][3];
  583.     long n;
  584.     int i;
  585.     n = data[0];
  586.     if (n >= MAXPOLY)
  587.     n = MAXPOLY;
  588.     for (i=0; i < n; i++) {
  589.     polydata[i][0] = data[3*i+1];
  590.     polydata[i][1] = data[3*i+2];
  591.     polydata[i][2] = data[3*i+3];
  592.     }
  593.     poly(n, polydata);
  594. #else
  595.     fprintf(stderr, "poly is broken, the #$*& compiler won't deal with it!\n");
  596. #endif
  597. }
  598.  
  599. static void interp_polyimage(int* data) {
  600.     register long x;
  601.     long y;
  602.     long* image;
  603.     register long* bottom;
  604.     register long* top;
  605.     long bvertex[2],tvertex[2];
  606.  
  607.     image = (long*)data[2];
  608.     for (y=0; y<data[1]; y++) {
  609.     bottom = image + y*data[1];
  610.     top = image + (y+1)*data[1];
  611.     bvertex[1] = y;
  612.     tvertex[1] = y+1;
  613.     bgntmesh();
  614.     for (x=0; x<=data[0]; x++) {
  615.         cpack(bottom[x]);
  616.         bvertex[0] = x;
  617.         v2i(bvertex);
  618.         cpack(top[x]);
  619.         tvertex[0] = x;
  620.         v2i(tvertex);
  621.     }
  622.     endtmesh();
  623.     }
  624. }
  625.  
  626. static void interp_polymode(int* data) {
  627.     polymode(data[0]);
  628. }
  629.  
  630. static void interp_polysmooth(int* data) {
  631.     polysmooth(data[0]);
  632. }
  633.  
  634. static void interp_readsource(int* data) {
  635.     readsource(data[0]);
  636. }
  637.  
  638. static void interp_rect(float* data) {
  639.     rect(data[0],data[1],data[2],data[3]);
  640. }
  641.  
  642. static void interp_rectcopy(int* data) {
  643.     rectcopy(data[0],data[1],data[2],data[3],data[4],data[5]);
  644. }
  645.  
  646. static void interp_rectf(float* data) {
  647.     rectf(data[0],data[1],data[2],data[3]);
  648. }
  649.  
  650. static void interp_rectzoom(float* data) {
  651.     rectzoom(data[0],data[1]);
  652. }
  653.  
  654. static void interp_RGBcolor(int* data) {
  655.     RGBcolor(data[0],data[1],data[2]);
  656. }
  657.  
  658. static void interp_RGBwritemask(int* data) {
  659.     RGBwritemask(data[0],data[1],data[2]);
  660. }
  661.  
  662. static void interp_rot(float* data) {
  663.     int axis;
  664.     axis = (int)data[1];
  665.     rot(data[0],axis);
  666. }
  667.  
  668. static void interp_rotate(int* data) {
  669.     rotate(data[0],data[1]);
  670. }
  671.  
  672. static void interp_sbox(float* data) {
  673.     sbox(data[0],data[1],data[2],data[3]);
  674. }
  675.  
  676. static void interp_sboxf(float* data) {
  677.     sboxf(data[0],data[1],data[2],data[3]);
  678. }
  679.  
  680. static void interp_scale(float* data) {
  681.     scale(data[0],data[1],data[2]);
  682. }
  683.  
  684. static void interp_sclear(int* data) {
  685.     sclear(data[0]);
  686. }
  687.  
  688. static void interp_scrbox(int* data) {
  689.     scrbox(data[0]);
  690. }
  691.  
  692. static void interp_scrmask(int* data) {
  693.     scrmask(data[0],data[1],data[2],data[3]);
  694. }
  695.  
  696. static void interp_scrsubdivide(float* data) {
  697.     scrsubdivide((long)data[0],&data[1]);
  698. }
  699.  
  700. static void interp_setlinestyle(int* data) {
  701.     setlinestyle(data[0]);
  702. }
  703.  
  704. static void interp_setpattern(int* data) {
  705.     setpattern(data[0]);
  706. }
  707.  
  708. static void interp_shademodel(int* data) {
  709.     shademodel(data[0]);
  710. }
  711.  
  712. static void interp_shaderange(int* data) {
  713.     shaderange(data[0],data[1],data[2],data[3]);
  714. }
  715.  
  716. static void interp_stencil(int* data)  {
  717.     stencil(data[0],data[1],data[2],data[3],data[4],data[5],data[6]);
  718. }
  719.  
  720. static void interp_stensize(int* data) {
  721.     stensize(data[0]);
  722. }
  723.  
  724. static void interp_subpixel(int* data) {
  725.     subpixel(data[0]);
  726. }
  727.  
  728. static void interp_swritemask(int* data) {
  729.     swritemask(data[0]);
  730. }
  731.  
  732. static void interp_tevbind(int* data) {
  733.     tevbind(data[0],data[1]);
  734. }
  735.  
  736. static void interp_tevdef(float* data) {
  737.     tevdef((long)data[0],(long)data[1],&data[2]);
  738. }
  739.  
  740. static void interp_texbind(int* data) {
  741.     texbind(data[0],data[1]);
  742. }
  743.  
  744. static void interp_texdef2d(float* data) {
  745.     texdef2d((long)data[0],(long)data[1],(long)data[2],(long)data[3],
  746.     (unsigned long **)(&data[4]),(long)data[5],&data[6]);
  747. }
  748.  
  749. static void interp_texgen(float* data) {
  750.     texgen((long)data[0],(long)data[1],&data[2]);
  751. }
  752.  
  753. static void interp_translate(float* data) {
  754.     translate(data[0],data[1],data[2]);
  755. }
  756.  
  757. static void interp_underlay(int* data) {
  758.     underlay(data[0]);
  759. }
  760.  
  761. static void interp_viewport(int* data) {
  762.     viewport(data[0],data[1],data[2],data[3]);
  763. }
  764.  
  765. static void interp_wmpack(int* data) {
  766.     wmpack(data[0]);
  767. }
  768.  
  769. static void interp_window(float* data) {
  770.     window(data[0],data[1],data[2],data[3],data[4],data[5]);
  771. }
  772.  
  773. static void interp_writemask(int* data) {
  774.     writemask(data[0]);
  775. }
  776.  
  777. static void interp_zbuffer(int* data) {
  778.     zbuffer(data[0]);
  779. }
  780.  
  781. static void interp_zdraw(int* data) {
  782.     zdraw(data[0]);
  783. }
  784.  
  785. static void interp_zfunction(int* data) {
  786.     zfunction(data[0]);
  787. }
  788.  
  789. static void interp_zsource(int* data) {
  790.     zsource(data[0]);
  791. }
  792.  
  793. static void interp_zwritemask(int* data) {
  794.     zwritemask(data[0]);
  795. }
  796.  
  797. /*
  798.  *    Initialize the interp system
  799.  */
  800.  
  801. void interpinit(int argc, char** argv) {
  802.     awkInit(argc,argv);
  803.  
  804.     grouptype(GRP_POLYGON);
  805.     CommandNumber = awkNewArray("CommandNumber",AWK_INT);
  806.     Constant = awkNewArray("Constant",AWK_INT);
  807.     ImagePointer = awkNewArray("ImagePointer",AWK_POINTER);
  808.     FilePointers = awkNewArray("FilePointers",AWK_POINTER);
  809.  
  810.     awkAddInt(CommandNumber,"acbuf",ACBUF);
  811.     awkAddInt(CommandNumber,"acsize",ACSIZE);
  812.     awkAddInt(CommandNumber,"addtopup",ADDTOPUP);
  813.     awkAddInt(CommandNumber,"afunction",AFUNCTION);
  814.     awkAddInt(CommandNumber,"arc",ARC);
  815.     awkAddInt(CommandNumber,"arcf",ARCF);
  816.     awkAddInt(CommandNumber,"arcfi",ARCFI);
  817.     awkAddInt(CommandNumber,"arcfs",ARCFS);
  818.     awkAddInt(CommandNumber,"arci",ARCI);
  819.     awkAddInt(CommandNumber,"arcs",ARCS);
  820.     awkAddInt(CommandNumber,"attachcursor",ATTACHCURSOR);
  821.     awkAddInt(CommandNumber,"backbuffer",BACKBUFFER);
  822.     awkAddInt(CommandNumber,"backface",BACKFACE);
  823.     awkAddInt(CommandNumber,"box",BOX);
  824.     awkAddInt(CommandNumber,"bboxR",BBOX2);
  825.     awkAddInt(CommandNumber,"bboxRi",BBOX2I);
  826.     awkAddInt(CommandNumber,"bboxRs",BBOX2S);
  827.     awkAddInt(CommandNumber,"bgnclosedline",BGNCLOSEDLINE);
  828.     awkAddInt(CommandNumber,"bgnline",BGNLINE);
  829.     awkAddInt(CommandNumber,"bgnpoint",BGNPOINT);
  830.     awkAddInt(CommandNumber,"bgnpolygon",BGNPOLYGON);
  831.     awkAddInt(CommandNumber,"bgnqstrip",BGNQSTRIP);
  832.     awkAddInt(CommandNumber,"bgntmesh",BGNTMESH);
  833.     awkAddInt(CommandNumber,"blankscreen",BLANKSCREEN);
  834.     awkAddInt(CommandNumber,"blanktime",BLANKTIME);
  835.     awkAddInt(CommandNumber,"blendfunction",BLENDFUNCTION);
  836.     awkAddInt(CommandNumber,"blink",BLINK);
  837.     awkAddInt(CommandNumber,"c3f",C3F);
  838.     awkAddInt(CommandNumber,"c3i",C3I);
  839.     awkAddInt(CommandNumber,"c3s",C3S);
  840.     awkAddInt(CommandNumber,"c4f",C4F);
  841.     awkAddInt(CommandNumber,"c4i",C4I);
  842.     awkAddInt(CommandNumber,"c4s",C4S);
  843.     awkAddInt(CommandNumber,"callobj",CALLOBJ);
  844.     awkAddInt(CommandNumber,"charstr",CHARSTR);
  845.     awkAddInt(CommandNumber,"chunksize",CHUNKSIZE);
  846.     awkAddInt(CommandNumber,"circ",CIRC);
  847.     awkAddInt(CommandNumber,"circf",CIRCF);
  848.     awkAddInt(CommandNumber,"circfi",CIRCFI);
  849.     awkAddInt(CommandNumber,"circfs",CIRCFS);
  850.     awkAddInt(CommandNumber,"circi",CIRCI);
  851.     awkAddInt(CommandNumber,"circs",CIRCS);
  852.     awkAddInt(CommandNumber,"clear",CLEAR);
  853.     awkAddInt(CommandNumber,"clearhitcode",CLEARHITCODE);
  854.     awkAddInt(CommandNumber,"clipplane",CLIPPLANE);
  855.     awkAddInt(CommandNumber,"clkoff",CLKOFF);
  856.     awkAddInt(CommandNumber,"clkon",CLKON);
  857.     awkAddInt(CommandNumber,"closeobj",CLOSEOBJ);
  858.     awkAddInt(CommandNumber,"cmode",CMODE);
  859.     awkAddInt(CommandNumber,"cmov",CMOV);
  860.     awkAddInt(CommandNumber,"cmov2",CMOV2);
  861.     awkAddInt(CommandNumber,"cmov2i",CMOV2I);
  862.     awkAddInt(CommandNumber,"cmov2s",CMOV2S);
  863.     awkAddInt(CommandNumber,"cmovi",CMOVI);
  864.     awkAddInt(CommandNumber,"cmovs",CMOVS);
  865.     awkAddInt(CommandNumber,"color",COLOR);
  866.     awkAddInt(CommandNumber,"colorf",COLORF);
  867.     awkAddInt(CommandNumber,"compactify",COMPACTIFY);
  868.     awkAddInt(CommandNumber,"concave",CONCAVE);
  869.     awkAddInt(CommandNumber,"cpack",CPACK);
  870.     awkAddInt(CommandNumber,"crv",CRV);
  871.     awkAddInt(CommandNumber,"crvn",CRVN);
  872.     awkAddInt(CommandNumber,"curorigin",CURORIGIN);
  873.     awkAddInt(CommandNumber,"cursoff",CURSOFF);
  874.     awkAddInt(CommandNumber,"curson",CURSON);
  875.     awkAddInt(CommandNumber,"curstype",CURSTYPE);
  876.     awkAddInt(CommandNumber,"curvebasis",CURVEBASIS);
  877.     awkAddInt(CommandNumber,"curveit",CURVEIT);
  878.     awkAddInt(CommandNumber,"curveprecision",CURVEPRECISION);
  879.     awkAddInt(CommandNumber,"cyclemap",CYCLEMAP);
  880.     awkAddInt(CommandNumber,"czclear",CZCLEAR);
  881.     awkAddInt(CommandNumber,"dbtext",DBTEXT);
  882.     awkAddInt(CommandNumber,"defbasis",DEFBASIS);
  883.     awkAddInt(CommandNumber,"defcursor",DEFCURSOR);
  884.     awkAddInt(CommandNumber,"deflinestyle",DEFLINESTYLE);
  885.     awkAddInt(CommandNumber,"defpattern",DEFPATTERN);
  886.     awkAddInt(CommandNumber,"defrasterfont",DEFRASTERFONT);
  887.     awkAddInt(CommandNumber,"delobj",DELOBJ);
  888.     awkAddInt(CommandNumber,"deltag",DELTAG);
  889.     awkAddInt(CommandNumber,"depthcue",DEPTHCUE);
  890.     awkAddInt(CommandNumber,"devport",DEVPORT);
  891.     awkAddInt(CommandNumber,"displacepolygon",DISPLACEPOLYGON);
  892.     awkAddInt(CommandNumber,"doublebuffer",DOUBLEBUFFER);
  893.     awkAddInt(CommandNumber,"draw",DRAW);
  894.     awkAddInt(CommandNumber,"drawR",DRAW2);
  895.     awkAddInt(CommandNumber,"drawRi",DRAW2I);
  896.     awkAddInt(CommandNumber,"drawRs",DRAW2S);
  897.     awkAddInt(CommandNumber,"drawi",DRAWI);
  898.     awkAddInt(CommandNumber,"drawmode",DRAWMODE);
  899.     awkAddInt(CommandNumber,"draws",DRAWS);
  900.     awkAddInt(CommandNumber,"editobj",EDITOBJ);
  901.     awkAddInt(CommandNumber,"endclosedline",ENDCLOSEDLINE);
  902.     awkAddInt(CommandNumber,"endfullscrn",ENDFULLSCRN);
  903.     awkAddInt(CommandNumber,"endline",ENDLINE);
  904.     awkAddInt(CommandNumber,"endpoint",ENDPOINT);
  905.     awkAddInt(CommandNumber,"endpolygon",ENDPOLYGON);
  906.     awkAddInt(CommandNumber,"endqstrip",ENDQSTRIP);
  907.     awkAddInt(CommandNumber,"endtmesh",ENDTMESH);
  908.     awkAddInt(CommandNumber,"feedback",FEEDBACK);
  909.     awkAddInt(CommandNumber,"finish",FINISH);
  910.     awkAddInt(CommandNumber,"fogvertex",FOGVERTEX);
  911.     awkAddInt(CommandNumber,"font",FONT);
  912.     awkAddInt(CommandNumber,"foreground",FOREGROUND);
  913.     awkAddInt(CommandNumber,"freepup",FREEPUP);
  914.     awkAddInt(CommandNumber,"frontbuffer",FRONTBUFFER);
  915.     awkAddInt(CommandNumber,"frontface",FRONTFACE);
  916.     awkAddInt(CommandNumber,"fudge",FUDGE);
  917.     awkAddInt(CommandNumber,"fullscrn",FULLSCRN);
  918.     awkAddInt(CommandNumber,"gammaramp",GAMMARAMP);
  919.     awkAddInt(CommandNumber,"gbegin",GBEGIN);
  920.     awkAddInt(CommandNumber,"gconfig",GCONFIG);
  921.     awkAddInt(CommandNumber,"gewrite",GEWRITE);
  922.     awkAddInt(CommandNumber,"gexit",GEXIT);
  923.     awkAddInt(CommandNumber,"gflush",GFLUSH);
  924.     awkAddInt(CommandNumber,"ginit",GINIT);
  925.     awkAddInt(CommandNumber,"glcompat",GLCOMPAT);
  926.     awkAddInt(CommandNumber,"greset",GRESET);
  927.     awkAddInt(CommandNumber,"gselect",GSELECT);
  928.     awkAddInt(CommandNumber,"gsync",GSYNC);
  929.     awkAddInt(CommandNumber,"hollowcolor",HOLLOWCOLOR);
  930.     awkAddInt(CommandNumber,"hollowwidth",HOLLOWWIDTH);
  931.     awkAddInt(CommandNumber,"imakebackground",IMAKEBACKGROUND);
  932.     awkAddInt(CommandNumber,"initnames",INITNAMES);
  933.     awkAddInt(CommandNumber,"keepaspect",KEEPASPECT);
  934.     awkAddInt(CommandNumber,"lampoff",LAMPOFF);
  935.     awkAddInt(CommandNumber,"lampon",LAMPON);
  936.     awkAddInt(CommandNumber,"linesmooth",LINESMOOTH);
  937.     awkAddInt(CommandNumber,"linewidth",LINEWIDTH);
  938.     awkAddInt(CommandNumber,"lmbind",LMBIND);
  939.     awkAddInt(CommandNumber,"lmcolor",LMCOLOR);
  940.     awkAddInt(CommandNumber,"lmdef",LMDEF);
  941.     awkAddInt(CommandNumber,"loadmatrix",LOADMATRIX);
  942.     awkAddInt(CommandNumber,"loadname",LOADNAME);
  943.     awkAddInt(CommandNumber,"logicop",LOGICOP);
  944.     awkAddInt(CommandNumber,"lookat",LOOKAT);
  945.     awkAddInt(CommandNumber,"lrectwrite",LRECTWRITE);
  946.     awkAddInt(CommandNumber,"lRGBrange",LRGBRANGE);
  947.     awkAddInt(CommandNumber,"lsbackup",LSBACKUP);
  948.     awkAddInt(CommandNumber,"lsetdepth",LSETDEPTH);
  949.     awkAddInt(CommandNumber,"lshaderange",LSHADERANGE);
  950.     awkAddInt(CommandNumber,"lsrepeat",LSREPEAT);
  951.     awkAddInt(CommandNumber,"makeobj",MAKEOBJ);
  952.     awkAddInt(CommandNumber,"maketag",MAKETAG);
  953.     awkAddInt(CommandNumber,"mapcolor",MAPCOLOR);
  954.     awkAddInt(CommandNumber,"mapw",MAPW);
  955.     awkAddInt(CommandNumber,"mapw2",MAPW2);
  956.     awkAddInt(CommandNumber,"maxsize",MAXSIZE);
  957.     awkAddInt(CommandNumber,"minsize",MINSIZE);
  958.     awkAddInt(CommandNumber,"mmode",MMODE);
  959.     awkAddInt(CommandNumber,"move",MOVE);
  960.     awkAddInt(CommandNumber,"move2",MOVE2);
  961.     awkAddInt(CommandNumber,"move2i",MOVE2I);
  962.     awkAddInt(CommandNumber,"move2s",MOVE2S);
  963.     awkAddInt(CommandNumber,"movei",MOVEI);
  964.     awkAddInt(CommandNumber,"moves",MOVES);
  965.     awkAddInt(CommandNumber,"mswapbuffers",MSWAPBUFFERS);
  966.     awkAddInt(CommandNumber,"multimap",MULTIMAP);
  967.     awkAddInt(CommandNumber,"multmatrix",MULTMATRIX);
  968.     awkAddInt(CommandNumber,"n3f",N3F);
  969.     awkAddInt(CommandNumber,"newtag",NEWTAG);
  970.     awkAddInt(CommandNumber,"nmode",NMODE);
  971.     awkAddInt(CommandNumber,"noborder",NOBORDER);
  972.     awkAddInt(CommandNumber,"noise",NOISE);
  973.     awkAddInt(CommandNumber,"noport",NOPORT);
  974.     awkAddInt(CommandNumber,"normal",NORMAL);
  975.     awkAddInt(CommandNumber,"objdelete",OBJDELETE);
  976.     awkAddInt(CommandNumber,"objinsert",OBJINSERT);
  977.     awkAddInt(CommandNumber,"objreplace",OBJREPLACE);
  978.     awkAddInt(CommandNumber,"onemap",ONEMAP);
  979.     awkAddInt(CommandNumber,"ortho",ORTHO);
  980.     awkAddInt(CommandNumber,"orthoR",ORTHO2);
  981.     awkAddInt(CommandNumber,"overlay",OVERLAY);
  982.     awkAddInt(CommandNumber,"pagewritemask",PAGEWRITEMASK);
  983.     awkAddInt(CommandNumber,"passthrough",PASSTHROUGH);
  984.     awkAddInt(CommandNumber,"patch",PATCH);
  985.     awkAddInt(CommandNumber,"patchbasis",PATCHBASIS);
  986.     awkAddInt(CommandNumber,"patchcurves",PATCHCURVES);
  987.     awkAddInt(CommandNumber,"patchprecision",PATCHPRECISION);
  988.     awkAddInt(CommandNumber,"pclos",PCLOS);
  989.     awkAddInt(CommandNumber,"pdr",PDR);
  990.     awkAddInt(CommandNumber,"pdr2",PDR2);
  991.     awkAddInt(CommandNumber,"pdr2i",PDR2I);
  992.     awkAddInt(CommandNumber,"pdr2s",PDR2S);
  993.     awkAddInt(CommandNumber,"pdri",PDRI);
  994.     awkAddInt(CommandNumber,"pdrs",PDRS);
  995.     awkAddInt(CommandNumber,"perspective",PERSPECTIVE);
  996.     awkAddInt(CommandNumber,"pick",PICK);
  997.     awkAddInt(CommandNumber,"picksize",PICKSIZE);
  998.     awkAddInt(CommandNumber,"pixmode",PIXMODE);
  999.     awkAddInt(CommandNumber,"pmv",PMV);
  1000.     awkAddInt(CommandNumber,"pmv2",PMV2);
  1001.     awkAddInt(CommandNumber,"pmv2i",PMV2I);
  1002.     awkAddInt(CommandNumber,"pmv2s",PMV2S);
  1003.     awkAddInt(CommandNumber,"pmvi",PMVI);
  1004.     awkAddInt(CommandNumber,"pmvs",PMVS);
  1005.     awkAddInt(CommandNumber,"pnt",PNT);
  1006.     awkAddInt(CommandNumber,"pnt2",PNT2);
  1007.     awkAddInt(CommandNumber,"pnt2i",PNT2I);
  1008.     awkAddInt(CommandNumber,"pnt2s",PNT2S);
  1009.     awkAddInt(CommandNumber,"pnti",PNTI);
  1010.     awkAddInt(CommandNumber,"pnts",PNTS);
  1011.     awkAddInt(CommandNumber,"pntsize",PNTSIZE);
  1012.     awkAddInt(CommandNumber,"pntsmooth",PNTSMOOTH);
  1013.     awkAddInt(CommandNumber,"polarview",POLARVIEW);
  1014.     awkAddInt(CommandNumber,"polf",POLF);
  1015.     awkAddInt(CommandNumber,"polf2",POLF2);
  1016.     awkAddInt(CommandNumber,"polf2i",POLF2I);
  1017.     awkAddInt(CommandNumber,"polf2s",POLF2S);
  1018.     awkAddInt(CommandNumber,"polfi",POLFI);
  1019.     awkAddInt(CommandNumber,"polfs",POLFS);
  1020.     awkAddInt(CommandNumber,"poly",POLY);
  1021.     awkAddInt(CommandNumber,"poly2",POLY2);
  1022.     awkAddInt(CommandNumber,"poly2i",POLY2I);
  1023.     awkAddInt(CommandNumber,"poly2s",POLY2S);
  1024.     awkAddInt(CommandNumber,"polyi",POLYI);
  1025.     awkAddInt(CommandNumber,"polymode",POLYMODE);
  1026.     awkAddInt(CommandNumber,"polys",POLYS);
  1027.     awkAddInt(CommandNumber,"polysmooth",POLYSMOOTH);
  1028.     awkAddInt(CommandNumber,"popattributes",POPATTRIBUTES);
  1029.     awkAddInt(CommandNumber,"popmatrix",POPMATRIX);
  1030.     awkAddInt(CommandNumber,"popname",POPNAME);
  1031.     awkAddInt(CommandNumber,"popviewport",POPVIEWPORT);
  1032.     awkAddInt(CommandNumber,"prefposition",PREFPOSITION);
  1033.     awkAddInt(CommandNumber,"prefsize",PREFSIZE);
  1034.     awkAddInt(CommandNumber,"pushattributes",PUSHATTRIBUTES);
  1035.     awkAddInt(CommandNumber,"pushmatrix",PUSHMATRIX);
  1036.     awkAddInt(CommandNumber,"pushname",PUSHNAME);
  1037.     awkAddInt(CommandNumber,"pushviewport",PUSHVIEWPORT);
  1038.     awkAddInt(CommandNumber,"qdevice",QDEVICE);
  1039.     awkAddInt(CommandNumber,"qenter",QENTER);
  1040.     awkAddInt(CommandNumber,"qreset",QRESET);
  1041.     awkAddInt(CommandNumber,"rcrv",RCRV);
  1042.     awkAddInt(CommandNumber,"rcrvn",RCRVN);
  1043.     awkAddInt(CommandNumber,"rdr",RDR);
  1044.     awkAddInt(CommandNumber,"rdr2",RDR2);
  1045.     awkAddInt(CommandNumber,"rdr2i",RDR2I);
  1046.     awkAddInt(CommandNumber,"rdr2s",RDR2S);
  1047.     awkAddInt(CommandNumber,"rdri",RDRI);
  1048.     awkAddInt(CommandNumber,"rdrs",RDRS);
  1049.     awkAddInt(CommandNumber,"readsource",READSOURCE);
  1050.     awkAddInt(CommandNumber,"rect",RECT);
  1051.     awkAddInt(CommandNumber,"rectcopy",RECTCOPY);
  1052.     awkAddInt(CommandNumber,"rectf",RECTF);
  1053.     awkAddInt(CommandNumber,"rectfi",RECTFI);
  1054.     awkAddInt(CommandNumber,"rectfs",RECTFS);
  1055.     awkAddInt(CommandNumber,"recti",RECTI);
  1056.     awkAddInt(CommandNumber,"rects",RECTS);
  1057.     awkAddInt(CommandNumber,"rectwrite",RECTWRITE);
  1058.     awkAddInt(CommandNumber,"rectzoom",RECTZOOM);
  1059.     awkAddInt(CommandNumber,"resetls",RESETLS);
  1060.     awkAddInt(CommandNumber,"reshapeviewport",RESHAPEVIEWPORT);
  1061.     awkAddInt(CommandNumber,"RGBcolor",RGBCOLOR);
  1062.     awkAddInt(CommandNumber,"RGBcursor",RGBCURSOR);
  1063.     awkAddInt(CommandNumber,"RGBmode",RGBMODE);
  1064.     awkAddInt(CommandNumber,"RGBrange",RGBRANGE);
  1065.     awkAddInt(CommandNumber,"RGBwritemask",RGBWRITEMASK);
  1066.     awkAddInt(CommandNumber,"ringbell",RINGBELL);
  1067.     awkAddInt(CommandNumber,"rmv",RMV);
  1068.     awkAddInt(CommandNumber,"rmv2",RMV2);
  1069.     awkAddInt(CommandNumber,"rmv2i",RMV2I);
  1070.     awkAddInt(CommandNumber,"rmv2s",RMV2S);
  1071.     awkAddInt(CommandNumber,"rmvi",RMVI);
  1072.     awkAddInt(CommandNumber,"rmvs",RMVS);
  1073.     awkAddInt(CommandNumber,"rot",ROT);
  1074.     awkAddInt(CommandNumber,"rotate",ROTATE);
  1075.     awkAddInt(CommandNumber,"rpatch",RPATCH);
  1076.     awkAddInt(CommandNumber,"rpdr",RPDR);
  1077.     awkAddInt(CommandNumber,"rpdr2",RPDR2);
  1078.     awkAddInt(CommandNumber,"rpdr2i",RPDR2I);
  1079.     awkAddInt(CommandNumber,"rpdr2s",RPDR2S);
  1080.     awkAddInt(CommandNumber,"rpdri",RPDRI);
  1081.     awkAddInt(CommandNumber,"rpdrs",RPDRS);
  1082.     awkAddInt(CommandNumber,"rpmv",RPMV);
  1083.     awkAddInt(CommandNumber,"rpmv2",RPMV2);
  1084.     awkAddInt(CommandNumber,"rpmv2i",RPMV2I);
  1085.     awkAddInt(CommandNumber,"rpmv2s",RPMV2S);
  1086.     awkAddInt(CommandNumber,"rpmvi",RPMVI);
  1087.     awkAddInt(CommandNumber,"rpmvs",RPMVS);
  1088.     awkAddInt(CommandNumber,"sbox",SBOX);
  1089.     awkAddInt(CommandNumber,"sboxf",SBOXF);
  1090.     awkAddInt(CommandNumber,"scale",SCALE);
  1091.     awkAddInt(CommandNumber,"sclear",SCLEAR);
  1092.     awkAddInt(CommandNumber,"scrbox",SCRBOX);
  1093.     awkAddInt(CommandNumber,"screenspace",SCREENSPACE);
  1094.     awkAddInt(CommandNumber,"scrmask",SCRMASK);
  1095.     awkAddInt(CommandNumber,"scrsubdivide",SCRSUBDIVIDE);
  1096.     awkAddInt(CommandNumber,"setbell",SETBELL);
  1097.     awkAddInt(CommandNumber,"setcursor",SETCURSOR);
  1098.     awkAddInt(CommandNumber,"setdblights",SETDBLIGHTS);
  1099.     awkAddInt(CommandNumber,"setdepth",SETDEPTH);
  1100.     awkAddInt(CommandNumber,"setlinestyle",SETLINESTYLE);
  1101.     awkAddInt(CommandNumber,"setmap",SETMAP);
  1102.     awkAddInt(CommandNumber,"setmonitor",SETMONITOR);
  1103.     awkAddInt(CommandNumber,"setpattern",SETPATTERN);
  1104.     awkAddInt(CommandNumber,"setshade",SETSHADE);
  1105.     awkAddInt(CommandNumber,"setvaluator",SETVALUATOR);
  1106.     awkAddInt(CommandNumber,"setvideo",SETVIDEO);
  1107.     awkAddInt(CommandNumber,"shademodel",SHADEMODEL);
  1108.     awkAddInt(CommandNumber,"shaderange",SHADERANGE);
  1109.     awkAddInt(CommandNumber,"singlebuffer",SINGLEBUFFER);
  1110.     awkAddInt(CommandNumber,"spclos",SPCLOS);
  1111.     awkAddInt(CommandNumber,"splf",SPLF);
  1112.     awkAddInt(CommandNumber,"splfR",SPLF2);
  1113.     awkAddInt(CommandNumber,"splfRi",SPLF2I);
  1114.     awkAddInt(CommandNumber,"splfRs",SPLF2S);
  1115.     awkAddInt(CommandNumber,"splfi",SPLFI);
  1116.     awkAddInt(CommandNumber,"splfs",SPLFS);
  1117.     awkAddInt(CommandNumber,"stencil",STENCIL);
  1118.     awkAddInt(CommandNumber,"stensize",STENSIZE);
  1119.     awkAddInt(CommandNumber,"stepunit",STEPUNIT);
  1120.     awkAddInt(CommandNumber,"subpixel",SUBPIXEL);
  1121.     awkAddInt(CommandNumber,"swapbuffers",SWAPBUFFERS);
  1122.     awkAddInt(CommandNumber,"swapinterval",SWAPINTERVAL);
  1123.     awkAddInt(CommandNumber,"swaptmesh",SWAPTMESH);
  1124.     awkAddInt(CommandNumber,"t2f",T2F);
  1125.     awkAddInt(CommandNumber,"tevbind",TEVBIND);
  1126.     awkAddInt(CommandNumber,"tevdef",TEVDEF);
  1127.     awkAddInt(CommandNumber,"texbind",TEXBIND);
  1128.     awkAddInt(CommandNumber,"texdef2d",TEXDEF2D);
  1129.     awkAddInt(CommandNumber,"texgen",TEXGEN);
  1130.     awkAddInt(CommandNumber,"textinit",TEXTINIT);
  1131.     awkAddInt(CommandNumber,"textwritemask",TEXTWRITEMASK);
  1132.     awkAddInt(CommandNumber,"tie",TIE);
  1133.     awkAddInt(CommandNumber,"tpoff",TPOFF);
  1134.     awkAddInt(CommandNumber,"tpon",TPON);
  1135.     awkAddInt(CommandNumber,"translate",TRANSLATE);
  1136.     awkAddInt(CommandNumber,"underlay",UNDERLAY);
  1137.     awkAddInt(CommandNumber,"unqdevice",UNQDEVICE);
  1138.     awkAddInt(CommandNumber,"v2d",V2D);
  1139.     awkAddInt(CommandNumber,"v2f",V2F);
  1140.     awkAddInt(CommandNumber,"v2i",V2I);
  1141.     awkAddInt(CommandNumber,"v2s",V2S);
  1142.     awkAddInt(CommandNumber,"v3d",V3D);
  1143.     awkAddInt(CommandNumber,"v3f",V3F);
  1144.     awkAddInt(CommandNumber,"v3i",V3I);
  1145.     awkAddInt(CommandNumber,"v3s",V3S);
  1146.     awkAddInt(CommandNumber,"v4d",V4D);
  1147.     awkAddInt(CommandNumber,"v4f",V4F);
  1148.     awkAddInt(CommandNumber,"v4i",V4I);
  1149.     awkAddInt(CommandNumber,"v4s",V4S);
  1150.     awkAddInt(CommandNumber,"viewport",VIEWPORT);
  1151. /*  awkAddInt(CommandNumber,"winclose",WINCLOSE); */
  1152.     awkAddInt(CommandNumber,"winconstraints",WINCONSTRAINTS);
  1153.     awkAddInt(CommandNumber,"window",WINDOW);
  1154.     awkAddInt(CommandNumber,"winmove",WINMOVE);
  1155.     awkAddInt(CommandNumber,"winpop",WINPOP);
  1156.     awkAddInt(CommandNumber,"winposition",WINPOSITION);
  1157.     awkAddInt(CommandNumber,"winpush",WINPUSH);
  1158.     awkAddInt(CommandNumber,"winset",WINSET);
  1159.     awkAddInt(CommandNumber,"wintitle",WINTITLE);
  1160.     awkAddInt(CommandNumber,"wmpack",WMPACK);
  1161.     awkAddInt(CommandNumber,"writemask",WRITEMASK);
  1162.     awkAddInt(CommandNumber,"writepixels",WRITEPIXELS);
  1163.     awkAddInt(CommandNumber,"writeRGB",WRITERGB);
  1164.     awkAddInt(CommandNumber,"xfpt",XFPT);
  1165.     awkAddInt(CommandNumber,"xfpt2",XFPT2);
  1166.     awkAddInt(CommandNumber,"xfpt2i",XFPT2I);
  1167.     awkAddInt(CommandNumber,"xfpt2s",XFPT2S);
  1168.     awkAddInt(CommandNumber,"xfpt4",XFPT4);
  1169.     awkAddInt(CommandNumber,"xfpt4i",XFPT4I);
  1170.     awkAddInt(CommandNumber,"xfpt4s",XFPT4S);
  1171.     awkAddInt(CommandNumber,"xfpti",XFPTI);
  1172.     awkAddInt(CommandNumber,"xfpts",XFPTS);
  1173.     awkAddInt(CommandNumber,"zbuffer",ZBUFFER);
  1174.     awkAddInt(CommandNumber,"zclear",ZCLEAR);
  1175.     awkAddInt(CommandNumber,"zdraw",ZDRAW);
  1176.     awkAddInt(CommandNumber,"zfunction",ZFUNCTION);
  1177.     awkAddInt(CommandNumber,"zsource",ZSOURCE);
  1178.     awkAddInt(CommandNumber,"zwritemask",ZWRITEMASK);
  1179.  
  1180.     awkAddInt(CommandNumber,"bgngroup",BGNGROUP);
  1181.     awkAddInt(CommandNumber,"endgroup",ENDGROUP);
  1182.     awkAddInt(CommandNumber,"grouptype",GROUPTYPE);
  1183.  
  1184.     awkAddInt(CommandNumber,"fogvertex",TEXFOGVERTEX);
  1185.     awkAddInt(CommandNumber,"fginit",FGINIT);
  1186.     awkAddInt(CommandNumber,"texcontour",TEXCONTOUR);
  1187.     awkAddInt(CommandNumber,"texscale",TEXSCALE);
  1188.     awkAddInt(CommandNumber,"polyimage",POLYIMAGE);
  1189.  
  1190.     awkAddInt(Constant,"TRUE",TRUE);
  1191.     awkAddInt(Constant,"FALSE",FALSE);
  1192.     awkAddInt(Constant,"BLACK",BLACK);
  1193.     awkAddInt(Constant,"RED",RED);
  1194.     awkAddInt(Constant,"GREEN",GREEN);
  1195.     awkAddInt(Constant,"YELLOW",YELLOW);
  1196.     awkAddInt(Constant,"BLUE",BLUE);
  1197.     awkAddInt(Constant,"MAGENTA",MAGENTA);
  1198.     awkAddInt(Constant,"CYAN",CYAN);
  1199.     awkAddInt(Constant,"WHITE",WHITE);
  1200.     awkAddInt(Constant,"PUP_CLEAR",PUP_CLEAR);
  1201.     awkAddInt(Constant,"PUP_CURSOR",PUP_CURSOR);
  1202.     awkAddInt(Constant,"PUP_BLACK",PUP_BLACK);
  1203.     awkAddInt(Constant,"PUP_WHITE",PUP_WHITE);
  1204.     awkAddInt(Constant,"NORMALDRAW",NORMALDRAW);
  1205.     awkAddInt(Constant,"PUPDRAW",PUPDRAW);
  1206.     awkAddInt(Constant,"OVERDRAW",OVERDRAW);
  1207.     awkAddInt(Constant,"UNDERDRAW",UNDERDRAW);
  1208.     awkAddInt(Constant,"CURSORDRAW",CURSORDRAW);
  1209.     awkAddInt(Constant,"NORMALDRAW|OVERDRAW",NORMALDRAW|OVERDRAW);
  1210.     awkAddInt(Constant,"NORMALDRAW|UNDERDRAW",NORMALDRAW|UNDERDRAW);
  1211.     awkAddInt(Constant,"PATTERN_16",PATTERN_16);
  1212.     awkAddInt(Constant,"PATTERN_32",PATTERN_32);
  1213.     awkAddInt(Constant,"PATTERN_64",PATTERN_64);
  1214.     awkAddInt(Constant,"PATTERN_16_SIZE",PATTERN_16_SIZE);
  1215.     awkAddInt(Constant,"PATTERN_32_SIZE",PATTERN_32_SIZE);
  1216.     awkAddInt(Constant,"PATTERN_64_SIZE",PATTERN_64_SIZE);
  1217.     awkAddInt(Constant,"SRC_AUTO",SRC_AUTO);
  1218.     awkAddInt(Constant,"SRC_FRONT",SRC_FRONT);
  1219.     awkAddInt(Constant,"SRC_BACK",SRC_BACK);
  1220.     awkAddInt(Constant,"SRC_ZBUFFER",SRC_ZBUFFER);
  1221.     awkAddInt(Constant,"BF_ZERO",BF_ZERO);
  1222.     awkAddInt(Constant,"BF_ONE",BF_ONE);
  1223.     awkAddInt(Constant,"BF_DC",BF_DC);
  1224.     awkAddInt(Constant,"BF_SC",BF_SC);
  1225.     awkAddInt(Constant,"BF_MDC",BF_MDC);
  1226.     awkAddInt(Constant,"BF_MSC",BF_MSC);
  1227.     awkAddInt(Constant,"BF_SA",BF_SA);
  1228.     awkAddInt(Constant,"BF_MSA",BF_MSA);
  1229.     awkAddInt(Constant,"BF_DA",BF_DA);
  1230.     awkAddInt(Constant,"BF_MDA",BF_MDA);
  1231.     awkAddInt(Constant,"BF_MIN_SA_MDA",BF_MIN_SA_MDA);
  1232.     awkAddInt(Constant,"AF_NEVER",AF_NEVER);
  1233.     awkAddInt(Constant,"AF_LESS",AF_LESS);
  1234.     awkAddInt(Constant,"AF_EQUAL",AF_EQUAL);
  1235.     awkAddInt(Constant,"AF_LEQUAL",AF_LEQUAL);
  1236.     awkAddInt(Constant,"AF_GREATER",AF_GREATER);
  1237.     awkAddInt(Constant,"AF_NOTEQUAL",AF_NOTEQUAL);
  1238.     awkAddInt(Constant,"AF_GEQUAL",AF_GEQUAL);
  1239.     awkAddInt(Constant,"AF_ALWAYS",AF_ALWAYS);
  1240.     awkAddInt(Constant,"ZF_NEVER",ZF_NEVER);
  1241.     awkAddInt(Constant,"ZF_LESS",ZF_LESS);
  1242.     awkAddInt(Constant,"ZF_EQUAL",ZF_EQUAL);
  1243.     awkAddInt(Constant,"ZF_LEQUAL",ZF_LEQUAL);
  1244.     awkAddInt(Constant,"ZF_GREATER",ZF_GREATER);
  1245.     awkAddInt(Constant,"ZF_NOTEQUAL",ZF_NOTEQUAL);
  1246.     awkAddInt(Constant,"ZF_GEQUAL",ZF_GEQUAL);
  1247.     awkAddInt(Constant,"ZF_ALWAYS",ZF_ALWAYS);
  1248.     awkAddInt(Constant,"ZSRC_DEPTH",ZSRC_DEPTH);
  1249.     awkAddInt(Constant,"ZSRC_COLOR",ZSRC_COLOR);
  1250.     awkAddInt(Constant,"SMP_OFF",SMP_OFF);
  1251.     awkAddInt(Constant,"SMP_ON",SMP_ON);
  1252.     awkAddInt(Constant,"SMP_SMOOTHER",SMP_SMOOTHER);
  1253.     awkAddInt(Constant,"SMP_ON|SMP_SMOOTHER",SMP_ON|SMP_SMOOTHER);
  1254.     awkAddInt(Constant,"SML_OFF",SML_OFF);
  1255.     awkAddInt(Constant,"SML_ON",SML_ON);
  1256.     awkAddInt(Constant,"SML_SMOOTHER",SML_SMOOTHER);
  1257.     awkAddInt(Constant,"SML_ON|SML_SMOOTHER",SML_ON|SML_SMOOTHER);
  1258.     awkAddInt(Constant,"SML_END_CORRECT",SML_END_CORRECT);
  1259.     awkAddInt(Constant,"SML_ON|SML_END_CORRECT",SML_ON|SML_END_CORRECT);
  1260.     awkAddInt(Constant,"SML_SMOOTHER|SML_END_CORRECT",
  1261.     SML_SMOOTHER|SML_END_CORRECT);
  1262.     awkAddInt(Constant,"SML_ON|SML_SMOOTHER|SML_END_CORRECT",
  1263.     SML_ON|SML_SMOOTHER|SML_END_CORRECT);
  1264.     awkAddInt(Constant,"PYSM_OFF",PYSM_OFF);
  1265.     awkAddInt(Constant,"PYSM_ON",PYSM_ON);
  1266.     awkAddInt(Constant,"PYSM_SHRINK",PYSM_SHRINK);
  1267.     awkAddInt(Constant,"GLC_OLDPOLYGON",GLC_OLDPOLYGON);
  1268.     awkAddInt(Constant,"GLC_ZRANGEMAP",GLC_ZRANGEMAP);
  1269.     awkAddInt(Constant,"C16X1",C16X1);
  1270.     awkAddInt(Constant,"C16X2",C16X2);
  1271.     awkAddInt(Constant,"C32X1",C32X1);
  1272.     awkAddInt(Constant,"C32X2",C32X2);
  1273.     awkAddInt(Constant,"CCROSS",CCROSS);
  1274.     awkAddInt(Constant,"FLAT",FLAT);
  1275.     awkAddInt(Constant,"GOURAUD",GOURAUD);
  1276.     awkAddInt(Constant,"LO_ZERO",LO_ZERO);
  1277.     awkAddInt(Constant,"LO_AND",LO_AND);
  1278.     awkAddInt(Constant,"LO_ANDR",LO_ANDR);
  1279.     awkAddInt(Constant,"LO_SRC",LO_SRC);
  1280.     awkAddInt(Constant,"LO_ANDI",LO_ANDI);
  1281.     awkAddInt(Constant,"LO_DST",LO_DST);
  1282.     awkAddInt(Constant,"LO_XOR",LO_XOR);
  1283.     awkAddInt(Constant,"LO_OR",LO_OR);
  1284.     awkAddInt(Constant,"LO_NOR",LO_NOR);
  1285.     awkAddInt(Constant,"LO_XNOR",LO_XNOR);
  1286.     awkAddInt(Constant,"LO_NDST",LO_NDST);
  1287.     awkAddInt(Constant,"LO_ORR",LO_ORR);
  1288.     awkAddInt(Constant,"LO_NSRC",LO_NSRC);
  1289.     awkAddInt(Constant,"LO_ORI",LO_ORI);
  1290.     awkAddInt(Constant,"LO_NAND",LO_NAND);
  1291.     awkAddInt(Constant,"LO_ONE",LO_ONE);
  1292.     awkAddInt(Constant,"ST_KEEP",ST_KEEP);
  1293.     awkAddInt(Constant,"ST_ZERO",ST_ZERO);
  1294.     awkAddInt(Constant,"ST_REPLACE",ST_REPLACE);
  1295.     awkAddInt(Constant,"ST_INCR",ST_INCR);
  1296.     awkAddInt(Constant,"ST_DECR",ST_DECR);
  1297.     awkAddInt(Constant,"ST_INVERT",ST_INVERT);
  1298.     awkAddInt(Constant,"SF_NEVER",SF_NEVER);
  1299.     awkAddInt(Constant,"SF_LESS",SF_LESS);
  1300.     awkAddInt(Constant,"SF_EQUAL",SF_EQUAL);
  1301.     awkAddInt(Constant,"SF_LEQUAL",SF_LEQUAL);
  1302.     awkAddInt(Constant,"SF_GREATER",SF_GREATER);
  1303.     awkAddInt(Constant,"SF_NOTEQUAL",SF_NOTEQUAL);
  1304.     awkAddInt(Constant,"SF_GEQUAL",SF_GEQUAL);
  1305.     awkAddInt(Constant,"SF_ALWAYS",SF_ALWAYS);
  1306.     awkAddInt(Constant,"SS_OFF",SS_OFF);
  1307.     awkAddInt(Constant,"SS_DEPTH",SS_DEPTH);
  1308.     awkAddInt(Constant,"PYM_FILL",PYM_FILL);
  1309.     awkAddInt(Constant,"PYM_POINT",PYM_POINT);
  1310.     awkAddInt(Constant,"PYM_LINE",PYM_LINE);
  1311.     awkAddInt(Constant,"PYM_HOLLOW",PYM_HOLLOW);
  1312.     awkAddInt(Constant,"FG_OFF",FG_OFF);
  1313.     awkAddInt(Constant,"FG_ON",FG_ON);
  1314.     awkAddInt(Constant,"FG_DEFINE",FG_DEFINE);
  1315.     awkAddInt(Constant,"PM_SHIFT",PM_SHIFT);
  1316.     awkAddInt(Constant,"PM_EXPAND",PM_EXPAND);
  1317.     awkAddInt(Constant,"PM_C0",PM_C0);
  1318.     awkAddInt(Constant,"PM_C1",PM_C1);
  1319.     awkAddInt(Constant,"PM_ADD24",PM_ADD24);
  1320.     awkAddInt(Constant,"PM_SIZE",PM_SIZE);
  1321.     awkAddInt(Constant,"PM_OFFSET",PM_OFFSET);
  1322.     awkAddInt(Constant,"PM_STRIDE",PM_STRIDE);
  1323.     awkAddInt(Constant,"PM_TTOB",PM_TTOB);
  1324.     awkAddInt(Constant,"PM_RTOL",PM_RTOL);
  1325.     awkAddInt(Constant,"PM_ZDATA",PM_ZDATA);
  1326.     awkAddInt(Constant,"NAUTO",NAUTO);
  1327.     awkAddInt(Constant,"NNORMALIZE",NNORMALIZE);
  1328.     awkAddInt(Constant,"AC_CLEAR",AC_CLEAR);
  1329.     awkAddInt(Constant,"AC_ACCUMULATE",AC_ACCUMULATE);
  1330.     awkAddInt(Constant,"AC_CLEAR_ACCUMULATE",AC_CLEAR_ACCUMULATE);
  1331.     awkAddInt(Constant,"AC_RETURN",AC_RETURN);
  1332.     awkAddInt(Constant,"AC_MULT",AC_MULT);
  1333.     awkAddInt(Constant,"AC_ADD",AC_ADD);
  1334.     awkAddInt(Constant,"CP_OFF",CP_OFF);
  1335.     awkAddInt(Constant,"CP_ON",CP_ON);
  1336.     awkAddInt(Constant,"CP_DEFINE",CP_DEFINE);
  1337.     awkAddInt(Constant,"SB_RESET",SB_RESET);
  1338.     awkAddInt(Constant,"SB_TRACK",SB_TRACK);
  1339.     awkAddInt(Constant,"SB_HOLD",SB_HOLD);
  1340.     awkAddInt(Constant,"LMNULL",LMNULL);
  1341.     awkAddInt(Constant,"MSINGLE",MSINGLE);
  1342.     awkAddInt(Constant,"MPROJECTION",MPROJECTION);
  1343.     awkAddInt(Constant,"MVIEWING",MVIEWING);
  1344.     awkAddInt(Constant,"MTEXTURE",MTEXTURE);
  1345.     awkAddInt(Constant,"DEFMATERIAL",DEFMATERIAL);
  1346.     awkAddInt(Constant,"EMISSION",EMISSION);
  1347.     awkAddInt(Constant,"AMBIENT",AMBIENT);
  1348.     awkAddInt(Constant,"DIFFUSE",DIFFUSE);
  1349.     awkAddInt(Constant,"SPECULAR",SPECULAR);
  1350.     awkAddInt(Constant,"SHININESS",SHININESS);
  1351.     awkAddInt(Constant,"COLORINDEXES",COLORINDEXES);
  1352.     awkAddInt(Constant,"ALPHA",ALPHA);
  1353.     awkAddInt(Constant,"DEFLIGHT",DEFLIGHT);
  1354.     awkAddInt(Constant,"LCOLOR",LCOLOR);
  1355.     awkAddInt(Constant,"POSITION",POSITION);
  1356.     awkAddInt(Constant,"SPOTDIRECTION",SPOTDIRECTION);
  1357.     awkAddInt(Constant,"SPOTLIGHT",SPOTLIGHT);
  1358.     awkAddInt(Constant,"DEFLMODEL",DEFLMODEL);
  1359.     awkAddInt(Constant,"LOCALVIEWER",LOCALVIEWER);
  1360.     awkAddInt(Constant,"ATTENUATION",ATTENUATION);
  1361.     awkAddInt(Constant,"ATTENUATION2",ATTENUATION2);
  1362.     awkAddInt(Constant,"TWOSIDE",TWOSIDE);
  1363.     awkAddInt(Constant,"MATERIAL",MATERIAL);
  1364.     awkAddInt(Constant,"BACKMATERIAL",BACKMATERIAL);
  1365.     awkAddInt(Constant,"LIGHT0",LIGHT0);
  1366.     awkAddInt(Constant,"LIGHT1",LIGHT1);
  1367.     awkAddInt(Constant,"LIGHT2",LIGHT2);
  1368.     awkAddInt(Constant,"LIGHT3",LIGHT3);
  1369.     awkAddInt(Constant,"LIGHT4",LIGHT4);
  1370.     awkAddInt(Constant,"LIGHT5",LIGHT5);
  1371.     awkAddInt(Constant,"LIGHT6",LIGHT6);
  1372.     awkAddInt(Constant,"LIGHT7",LIGHT7);
  1373.     awkAddInt(Constant,"LMODEL",LMODEL);
  1374.     awkAddInt(Constant,"LMC_COLOR",LMC_COLOR);
  1375.     awkAddInt(Constant,"LMC_EMISSION",LMC_EMISSION);
  1376.     awkAddInt(Constant,"LMC_AMBIENT",LMC_AMBIENT);
  1377.     awkAddInt(Constant,"LMC_DIFFUSE",LMC_DIFFUSE);
  1378.     awkAddInt(Constant,"LMC_SPECULAR",LMC_SPECULAR);
  1379.     awkAddInt(Constant,"LMC_AD",LMC_AD);
  1380.     awkAddInt(Constant,"LMC_NULL",LMC_NULL);
  1381.     awkAddInt(Constant,"TX_MINFILTER",TX_MINFILTER);
  1382.     awkAddInt(Constant,"TX_MAGFILTER",TX_MAGFILTER);
  1383.     awkAddInt(Constant,"TX_WRAP",TX_WRAP);
  1384.     awkAddInt(Constant,"TX_WRAP_S",TX_WRAP_S);
  1385.     awkAddInt(Constant,"TX_WRAP_T",TX_WRAP_T);
  1386.     awkAddInt(Constant,"TX_TILE",TX_TILE);
  1387.     awkAddInt(Constant,"TX_NULL",TX_NULL);
  1388.     awkAddInt(Constant,"TX_POINT",TX_POINT);
  1389.     awkAddInt(Constant,"TX_BILINEAR",TX_BILINEAR);
  1390.     awkAddInt(Constant,"TX_MIPMAP_POINT",TX_MIPMAP_POINT);
  1391.     awkAddInt(Constant,"TX_MIPMAP_LINEAR",TX_MIPMAP_LINEAR);
  1392.     awkAddInt(Constant,"TX_MIPMAP_BILINEAR",TX_MIPMAP_BILINEAR);
  1393.     awkAddInt(Constant,"TX_MIPMAP_TRILINEAR",TX_MIPMAP_TRILINEAR);
  1394.     awkAddInt(Constant,"TX_REPEAT",TX_REPEAT);
  1395.     awkAddInt(Constant,"TX_CLAMP",TX_CLAMP);
  1396.     awkAddInt(Constant,"TX_SELECT",TX_SELECT);
  1397.     awkAddInt(Constant,"TX_TEXTURE_0",TX_TEXTURE_0);
  1398.     awkAddInt(Constant,"TV_MODULATE",TV_MODULATE);
  1399.     awkAddInt(Constant,"TV_BLEND",TV_BLEND);
  1400.     awkAddInt(Constant,"TV_DECAL",TV_DECAL);
  1401.     awkAddInt(Constant,"TV_COLOR",TV_COLOR);
  1402.     awkAddInt(Constant,"TV_NULL",TV_NULL);
  1403.     awkAddInt(Constant,"TV_ENV0",TV_ENV0);
  1404.     awkAddInt(Constant,"TX_S",TX_S);
  1405.     awkAddInt(Constant,"TX_T",TX_T);
  1406.     awkAddInt(Constant,"TG_OFF",TG_OFF);
  1407.     awkAddInt(Constant,"TG_ON",TG_ON);
  1408.     awkAddInt(Constant,"TG_CONTOUR",TG_CONTOUR);
  1409.     awkAddInt(Constant,"TG_LINEAR",TG_LINEAR);
  1410.  
  1411.     awkAddInt(Constant,"GRP_POINT",GRP_POINT);
  1412.     awkAddInt(Constant,"GRP_LINE",GRP_LINE);
  1413.     awkAddInt(Constant,"GRP_CLOSEDLINE",GRP_CLOSEDLINE);
  1414.     awkAddInt(Constant,"GRP_POLYGON",GRP_POLYGON);
  1415.     awkAddInt(Constant,"GRP_TMESH",GRP_TMESH);
  1416.     awkAddInt(Constant,"GRP_HOLLOWPOLY",GRP_HOLLOWPOLY);
  1417. }
  1418.  
  1419. static long *nextword = 0;
  1420. static long wordsleft = 0;
  1421.  
  1422. /*
  1423.  *    Malloc and initialize a single element
  1424.  */
  1425.  
  1426. static element_t *make_element(void (*func)(), int words) {
  1427.     element_t* sp;
  1428.     int offset;
  1429.     int size;
  1430.     int maxsize;
  1431.     int aligned;    /* could become an argument - compute it for now */
  1432.  
  1433.     aligned = ((words>1) && (words<5));
  1434.     size = NONDATASIZE+words;
  1435.     if (aligned)
  1436.     maxsize = size+3;
  1437.     else
  1438.     maxsize = size;
  1439.     if (wordsleft < maxsize) {
  1440.     if ((nextword = (long*)malloc(MALLOCWORDS*4)) == 0) {
  1441.         fprintf(stderr,"make_element: malloc failed. abort.\n");
  1442.         awkExit();
  1443.         exit(1);
  1444.     }
  1445.     if ((long)nextword & 0x3) {
  1446.         fprintf(stderr,"make_element: malloc returned non-word addr\n");
  1447.         awkExit();
  1448.         exit(1);
  1449.     }
  1450.     wordsleft = MALLOCWORDS;
  1451.     }
  1452.     offset = 0;
  1453.     if (aligned) {
  1454.     int wordaddr;
  1455.     wordaddr = ((long)(nextword+NONDATASIZE)>>2) & 0x3;
  1456.     if ((wordaddr+words) > 4) {
  1457.         offset = 4-wordaddr;
  1458.         size += offset;
  1459.     }
  1460.     }
  1461.     sp = (element_t*)(nextword+offset);
  1462.     nextword += size;
  1463.     wordsleft -= size;
  1464.     sp->func = func;
  1465.     sp->next = 0;
  1466.     return sp;
  1467. }
  1468.  
  1469. /*
  1470.  *    Report an error if incorrect number of arguments is received
  1471.  */
  1472.  
  1473. static int argcount(int n) {
  1474.     if (n != (awkNF-1)) {
  1475.     fprintf(stderr,"%s line %d: incorrect argument count\n",
  1476.         awkFILENAME,awkNL);
  1477.     return 0;
  1478.     }
  1479.     return 1;
  1480. }
  1481.  
  1482. /*
  1483.  *    Report an error if incorrect number of arguments is received
  1484.  */
  1485.  
  1486. static int minargcount(int n) {
  1487.     if (n > (awkNF-1)) {
  1488.     fprintf(stderr,"%s line %d: insufficient argument count\n",
  1489.         awkFILENAME,awkNL);
  1490.     return 0;
  1491.     }
  1492.     return 1;
  1493. }
  1494.  
  1495. /*
  1496.  *    Maintain max and min for x, y, and z
  1497.  */
  1498.  
  1499. static void keepbounds(float x,float y,float z,float w) {
  1500.     if (w != 1.0) {
  1501.     x /= w;
  1502.     y /= w;
  1503.     z /= w;
  1504.     }
  1505.     if (x > xmax) xmax = x;
  1506.     if (x < xmin) xmin = x;
  1507.     if (y > ymax) ymax = y;
  1508.     if (y < ymin) ymin = y;
  1509.     if (z > zmax) zmax = z;
  1510.     if (z < zmin) zmin = z;
  1511.     vcount += 1;
  1512. }
  1513.  
  1514. void getbounds(float* Xmin,float* Xmax,float* Ymin,float* Ymax,float* Zmin,float* Zmax) {
  1515.     *Xmin = xmin;
  1516.     *Xmax = xmax;
  1517.     *Ymin = ymin;
  1518.     *Ymax = ymax;
  1519.     *Zmin = zmin;
  1520.     *Zmax = zmax;
  1521. }
  1522.  
  1523. static int ishexstr(char* s) {
  1524.     if (*s++ != '0')
  1525.     return FALSE;
  1526.     if (*s++ != 'x')
  1527.     return FALSE;
  1528.     while(TRUE) {
  1529.     switch(*s++) {
  1530.     case '0':
  1531.     case '1':
  1532.     case '2':
  1533.     case '3':
  1534.     case '4':
  1535.     case '5':
  1536.     case '6':
  1537.     case '7':
  1538.     case '8':
  1539.     case '9':
  1540.     case 'a':
  1541.     case 'b':
  1542.     case 'c':
  1543.     case 'd':
  1544.     case 'e':
  1545.     case 'f':
  1546.     case 'A':
  1547.     case 'B':
  1548.     case 'C':
  1549.     case 'D':
  1550.     case 'E':
  1551.     case 'F':
  1552.         break;
  1553.     case '\0':
  1554.         return TRUE;
  1555.     default:
  1556.         return FALSE;
  1557.     }
  1558.     }
  1559. }
  1560.  
  1561. static int isdecstr(char* s) {
  1562.     if (*s == '-' || *s == '+')
  1563.     s+=1;
  1564.     while(TRUE) {
  1565.     switch(*s++) {
  1566.     case '0':
  1567.     case '1':
  1568.     case '2':
  1569.     case '3':
  1570.     case '4':
  1571.     case '5':
  1572.     case '6':
  1573.     case '7':
  1574.     case '8':
  1575.     case '9':
  1576.         break;
  1577.     case '\0':
  1578.         return TRUE;
  1579.     default:
  1580.         return FALSE;
  1581.     }
  1582.     }
  1583. }
  1584.  
  1585. static int isfloatstr(char* s) {
  1586.     int gotdpoint;
  1587.     gotdpoint = FALSE;
  1588.     if (*s == '-' || *s == '+')
  1589.     s+=1;
  1590.     while(TRUE) {
  1591.     switch(*s++) {
  1592.     case '0':
  1593.     case '1':
  1594.     case '2':
  1595.     case '3':
  1596.     case '4':
  1597.     case '5':
  1598.     case '6':
  1599.     case '7':
  1600.     case '8':
  1601.     case '9':
  1602.         break;
  1603.     case '.':
  1604.         if (gotdpoint)
  1605.         return FALSE;
  1606.         else
  1607.         gotdpoint = TRUE;
  1608.         break;
  1609.     case 'e':
  1610.     case 'E':
  1611.         /* XXX - allows more than one exponent */
  1612.         return isfloatstr(s);
  1613.     case '\0':
  1614.         return TRUE;
  1615.     default:
  1616.         return FALSE;
  1617.     }
  1618.     }
  1619. }
  1620.  
  1621. /*
  1622.  *    Interpret an input field as an integer
  1623.  */
  1624.  
  1625. static int readint(int i) {
  1626.     register char* s;
  1627.     int j;
  1628.     s = awkARG[i+2];
  1629.     if (awkGetIndex(Constant,s))
  1630.     j = awkGetInt(Constant,s);
  1631.     else if (ishexstr(s))
  1632.     sscanf(s+2,"%x",&j);
  1633.     else if (isdecstr(s))
  1634.     sscanf(s,"%d",&j);
  1635.     else {
  1636.     fprintf(stderr,"%s line %d: unrecognized symbol <%s>\n",
  1637.         awkFILENAME,awkNL,s);
  1638.     exit(1);
  1639.     }
  1640.     return j;
  1641. }
  1642.  
  1643. /*
  1644.  *    Interpret an input field as a float
  1645.  */
  1646.  
  1647. static float readfloat(int i) {
  1648.     register char* s;
  1649.     float f;
  1650.     s = awkARG[i+2];
  1651.     if (awkGetIndex(Constant,s))
  1652.     f = awkGetInt(Constant,s);
  1653.     else if (isfloatstr(s))
  1654.     sscanf(s,"%f",&f);
  1655.     else {
  1656.     fprintf(stderr,"%s line %d: unrecognized symbol <%s>\n",
  1657.         awkFILENAME,awkNL,s);
  1658.     exit(1);
  1659.     }
  1660.     return f;
  1661. }
  1662.  
  1663. /*
  1664.  *    Interpret an input field as a character
  1665.  */
  1666.  
  1667. static int readchar(int i) {
  1668.     register char* s;
  1669.     s = awkARG[i+2];
  1670.     if (s[1])
  1671.     fprintf(stderr,"%s line %d: too many characters in field <%s>\n",
  1672.         awkFILENAME,awkNL,s);
  1673.     return s[0];
  1674. }
  1675.  
  1676. /*
  1677.  *    Measure the length of an input field to be interpreted as a string
  1678.  */
  1679.  
  1680. static int stringlength(int i) {
  1681.     return strlen(awkARG[i+2]);
  1682. }
  1683.  
  1684. /*
  1685.  *    Interpret an input field as a string
  1686.  */
  1687.  
  1688. static void readstring(int i,char* str) {
  1689.     register char *s;
  1690.     s = awkARG[i+2];
  1691.     while (*str++ = *s++);
  1692. }
  1693.  
  1694. /*
  1695.  *    Interpret a line of input
  1696.  */
  1697.  
  1698. static element_t *interpline(void) {
  1699.     element_t* sp;
  1700.     float_element_t* fp;
  1701.     int_element_t* ip;
  1702.     float fx,fy,fz,fw;
  1703.     float fx2,fy2,fz2;
  1704.     int command;
  1705.     int i;
  1706.     int size;
  1707.     int mode;
  1708.  
  1709.     command = awkGetInt(CommandNumber,awkARG[1]);
  1710.     if (command == 0) {
  1711.     if ((awkNF > 0) && (awkARG[1][0] != '#'))
  1712.         fprintf(stderr,"%s line %d: undefined command <%s>.  ignored.\n",
  1713.         awkFILENAME,awkNL,awkARG[1]);
  1714.     return 0;
  1715.     }
  1716.  
  1717.     switch (command) {
  1718.     case ACBUF:
  1719.         if (!argcount(2))
  1720.         return 0;
  1721.         fp = (float_element_t*)make_element(interp_acbuf,2);
  1722.         fp->arg[0] = readint(0);
  1723.         fp->arg[1] = readfloat(1);
  1724.         return (element_t*)fp;
  1725.     case ACSIZE:
  1726.         if (!argcount(1))
  1727.         return 0;
  1728.         ip = (int_element_t*)make_element(interp_acsize,1);
  1729.         ip->arg[0] = readint(0);
  1730.         return (element_t*)ip;
  1731.     case AFUNCTION:
  1732.         if (!argcount(2))
  1733.         return 0;
  1734.         ip = (int_element_t*)make_element(interp_afunction,2);
  1735.         ip->arg[0] = readint(0);
  1736.         ip->arg[1] = readint(1);
  1737.         return (element_t*)ip;
  1738.     case ARC:
  1739.         if (!argcount(5))
  1740.         return 0;
  1741.         fp = (float_element_t*)make_element(interp_arc,5);
  1742.         fp->arg[0] = readfloat(0);
  1743.         fp->arg[1] = readfloat(1);
  1744.         fp->arg[2] = readfloat(2);
  1745.         fp->arg[3] = readfloat(3);
  1746.         fp->arg[4] = readfloat(4);
  1747.         return (element_t*)fp;
  1748.     case ARCF:
  1749.         if (!argcount(5))
  1750.         return 0;
  1751.         fp = (float_element_t*)make_element(interp_arcf,5);
  1752.         fp->arg[0] = readfloat(0);
  1753.         fp->arg[1] = readfloat(1);
  1754.         fp->arg[2] = readfloat(2);
  1755.         fp->arg[3] = readfloat(3);
  1756.         fp->arg[4] = readfloat(4);
  1757.         return (element_t*)fp;
  1758.     case BACKBUFFER:
  1759.         if (!argcount(1))
  1760.         return 0;
  1761.         ip = (int_element_t*)make_element(interp_backbuffer,1);
  1762.         ip->arg[0] = readint(0);
  1763.         return (element_t*)ip;
  1764.     case BACKFACE:
  1765.         if (!argcount(1))
  1766.         return 0;
  1767.         ip = (int_element_t*)make_element(interp_backface,1);
  1768.         ip->arg[0] = readint(0);
  1769.         return (element_t*)ip;
  1770.     case BGNCLOSEDLINE:
  1771.         if (!argcount(0))
  1772.         return 0;
  1773.         breakok = FALSE;
  1774.         return make_element(bgnclosedline,0);
  1775.     case BGNGROUP:
  1776.         if (!argcount(0))
  1777.         return 0;
  1778.         breakok = FALSE;
  1779.         return make_element(interp_bgngroup,0);
  1780.     case BGNLINE:
  1781.         if (!argcount(0))
  1782.         return 0;
  1783.         breakok = FALSE;
  1784.         return make_element(bgnline,0);
  1785.     case BGNPOINT:
  1786.         if (!argcount(0))
  1787.         return 0;
  1788.         breakok = FALSE;
  1789.         return make_element(bgnpoint,0);
  1790.     case BGNPOLYGON:
  1791.         if (!argcount(0))
  1792.         return 0;
  1793.         breakok = FALSE;
  1794.         return make_element(bgnpolygon,0);
  1795.     case BGNQSTRIP:
  1796.         if (!argcount(0))
  1797.         return 0;
  1798.         breakok = FALSE;
  1799.         return make_element(bgnqstrip,0);
  1800.     case BGNTMESH:
  1801.         if (!argcount(0))
  1802.         return 0;
  1803.         breakok = FALSE;
  1804.         return make_element(bgntmesh,0);
  1805.     case BLENDFUNCTION:
  1806.         if (!argcount(2))
  1807.         return 0;
  1808.         ip = (int_element_t*)make_element(interp_blendfunction,2);
  1809.         ip->arg[0] = readint(0);
  1810.         ip->arg[1] = readint(1);
  1811.         return (element_t*)ip;
  1812.     case BLINK:
  1813.         if (!argcount(5))
  1814.         return 0;
  1815.         ip = (int_element_t*)make_element(interp_blink,5);
  1816.         ip->arg[0] = readint(0);
  1817.         ip->arg[1] = readint(1);
  1818.         ip->arg[2] = readint(2);
  1819.         ip->arg[3] = readint(3);
  1820.         ip->arg[4] = readint(4);
  1821.         return (element_t*)ip;
  1822.     case BOX:
  1823.         if (!argcount(6))
  1824.         return 0;
  1825.         fp = (float_element_t*)make_element(interp_box,32);
  1826.         fx = readfloat(0);
  1827.         fy = readfloat(1);
  1828.         fz = readfloat(2);
  1829.         fx2 = readfloat(3);
  1830.         fy2 = readfloat(4);
  1831.         fz2 = readfloat(5);
  1832.         keepbounds(fx,fy,fz,1.0);
  1833.         keepbounds(fx2,fy2,fz2,1.0);
  1834.         if (fx > fx2) {float f; f = fx; fx = fx2; fx2 = f;}
  1835.         if (fy > fy2) {float f; f = fy; fy = fy2; fy2 = f;}
  1836.         if (fz > fz2) {float f; f = fz; fz = fz2; fz2 = f;}
  1837.         fp->arg[0] = fx;
  1838.         fp->arg[1] = fy;
  1839.         fp->arg[2] = fz;
  1840.         fp->arg[3] = 1;
  1841.         fp->arg[4] = fx2;
  1842.         fp->arg[5] = fy;
  1843.         fp->arg[6] = fz;
  1844.         fp->arg[7] = 1;
  1845.         fp->arg[8] = fx;
  1846.         fp->arg[9] = fy2;
  1847.         fp->arg[10] = fz;
  1848.         fp->arg[11] = 1;
  1849.         fp->arg[12] = fx2;
  1850.         fp->arg[13] = fy2;
  1851.         fp->arg[14] = fz;
  1852.         fp->arg[15] = 1;
  1853.         fp->arg[16] = fx;
  1854.         fp->arg[17] = fy;
  1855.         fp->arg[18] = fz2;
  1856.         fp->arg[19] = 1;
  1857.         fp->arg[20] = fx2;
  1858.         fp->arg[21] = fy;
  1859.         fp->arg[22] = fz2;
  1860.         fp->arg[23] = 1;
  1861.         fp->arg[24] = fx;
  1862.         fp->arg[25] = fy2;
  1863.         fp->arg[26] = fz2;
  1864.         fp->arg[27] = 1;
  1865.         fp->arg[28] = fx2;
  1866.         fp->arg[29] = fy2;
  1867.         fp->arg[30] = fz2;
  1868.         fp->arg[31] = 1;
  1869.         return (element_t*)fp;
  1870.     case C3I:
  1871.         if (!argcount(3))
  1872.         return 0;
  1873.         ip = (int_element_t*)make_element(c3i,3);
  1874.         ip->arg[0] = readint(0);
  1875.         ip->arg[1] = readint(1);
  1876.         ip->arg[2] = readint(2);
  1877.         return (element_t*)ip;
  1878.     case C3F:
  1879.         if (!argcount(3))
  1880.         return 0;
  1881.         fp = (float_element_t*)make_element(c3f,3);
  1882.         fp->arg[0] = readfloat(0);
  1883.         fp->arg[1] = readfloat(1);
  1884.         fp->arg[2] = readfloat(2);
  1885.         return (element_t*)fp;
  1886.     case C4I:
  1887.         if (!argcount(4))
  1888.         return 0;
  1889.         ip = (int_element_t*)make_element(c4i,4);
  1890.         ip->arg[0] = readint(0);
  1891.         ip->arg[1] = readint(1);
  1892.         ip->arg[2] = readint(2);
  1893.         ip->arg[3] = readint(3);
  1894.         return (element_t*)ip;
  1895.     case C4F:
  1896.         if (!argcount(4))
  1897.         return 0;
  1898.         fp = (float_element_t*)make_element(c4f,4);
  1899.         fp->arg[0] = readfloat(0);
  1900.         fp->arg[1] = readfloat(1);
  1901.         fp->arg[2] = readfloat(2);
  1902.         fp->arg[3] = readfloat(3);
  1903.         return (element_t*)fp;
  1904.     case CALLOBJ:
  1905.         if (!argcount(1))
  1906.         return 0;
  1907.         {
  1908.         char bigstring[100];
  1909.         readstring(0,bigstring);
  1910.         if (i = (int)awkGetPointer(FilePointers,bigstring)) {
  1911.             ip = (int_element_t*)make_element(interp_callobj,1);
  1912.             ip->arg[0] = i;
  1913.         }
  1914.         else {
  1915.             ip = (int_element_t*)make_element(interp_callobj,
  1916.             1+((stringlength(0)+4)/4));
  1917.             ip->arg[0] = 0;
  1918.             strcpy((char*)&(ip->arg[1]),bigstring);
  1919.         }
  1920.         }
  1921.         return (element_t*)ip;
  1922.         break;
  1923.     case CHARSTR:
  1924.         if (!argcount(1))
  1925.         return 0;
  1926.         ip = (int_element_t*)make_element(interp_charstr,(stringlength(0)+4)/4);
  1927.         readstring(0,(char*)&(ip->arg[0]));
  1928.         return (element_t*)ip;
  1929.     case CIRC:
  1930.         if (!argcount(3))
  1931.         return 0;
  1932.         fp = (float_element_t*)make_element(interp_circ,3);
  1933.         fp->arg[0] = readfloat(0);
  1934.         fp->arg[1] = readfloat(1);
  1935.         fp->arg[2] = readfloat(2);
  1936.         return (element_t*)fp;
  1937.     case CIRCF:
  1938.         if (!argcount(3))
  1939.         return 0;
  1940.         fp = (float_element_t*)make_element(interp_circf,3);
  1941.         fp->arg[0] = readfloat(0);
  1942.         fp->arg[1] = readfloat(1);
  1943.         fp->arg[2] = readfloat(2);
  1944.         return (element_t*)fp;
  1945.     case CLIPPLANE:
  1946.         if (!minargcount(2))
  1947.         return 0;
  1948.         size = awkNF - 1;
  1949.         fp = (float_element_t*)make_element(interp_clipplane,size);
  1950.         fp->arg[0] = (float)readint(0);
  1951.         fp->arg[1] = (float)readint(1);
  1952.         for (i=2; i<size; i++)
  1953.         fp->arg[i] = readfloat(i);
  1954.         return (element_t*)fp;
  1955.     case CLEAR:
  1956.         if (!argcount(0))
  1957.         return 0;
  1958.         return make_element(clear,0);
  1959.     case CMODE:
  1960.         if (!argcount(0))
  1961.         return 0;
  1962.         return make_element(cmode,0);
  1963.     case CMOV:
  1964.         if (!argcount(3))
  1965.         return 0;
  1966.         fp = (float_element_t*)make_element(interp_cmov,3);
  1967.         fp->arg[0] = readfloat(0);
  1968.         fp->arg[1] = readfloat(1);
  1969.         fp->arg[2] = readfloat(2);
  1970.         return (element_t*)fp;
  1971.     case COLOR:
  1972.         if (!argcount(1))
  1973.         return 0;
  1974.         ip = (int_element_t*)make_element(interp_color,1);
  1975.         ip->arg[0] = readint(0);
  1976.         return (element_t*)ip;
  1977.     case COLORF:
  1978.         if (!argcount(1))
  1979.         return 0;
  1980.         fp = (float_element_t*)make_element(interp_colorf,1);
  1981.         fp->arg[0] = readfloat(0);
  1982.         return (element_t*)fp;
  1983.     case CONCAVE:
  1984.         if (!argcount(1))
  1985.         return 0;
  1986.         ip = (int_element_t*)make_element(interp_concave,1);
  1987.         ip->arg[0] = readint(0);
  1988.         return (element_t*)ip;
  1989.     case CPACK:
  1990.         if (!argcount(1))
  1991.         return 0;
  1992.         ip = (int_element_t*)make_element(interp_cpack,1);
  1993.         ip->arg[0] = readint(0);
  1994.         return (element_t*)ip;
  1995.     case CZCLEAR:
  1996.         if (!argcount(2))
  1997.         return 0;
  1998.         ip = (int_element_t*)make_element(interp_czclear,2);
  1999.         ip->arg[0] = readint(0);
  2000.         ip->arg[1] = readint(1);
  2001.         return (element_t*)ip;
  2002.     case DEFLINESTYLE:
  2003.         if (!argcount(2))
  2004.         return 0;
  2005.         ip = (int_element_t*)make_element(interp_deflinestyle,2);
  2006.         ip->arg[0] = readint(0);
  2007.         ip->arg[1] = readint(1);
  2008.         return (element_t*)ip;
  2009.     case DEFPATTERN:
  2010.         if (!minargcount(18))
  2011.         return 0;
  2012.         i = readint(1);
  2013.         size = i * (i>>4);
  2014.         if (!argcount(size+2))
  2015.         return 0;
  2016.         ip = (int_element_t*)make_element(interp_defpattern,2+size);
  2017.         ip->arg[0] = readint(0);
  2018.         ip->arg[1] = i;
  2019.         for (i=0; i<size; i++)
  2020.         ip->arg[i+2] = readint(i+2);
  2021.         return (element_t*)ip;
  2022.     case DEPTHCUE:
  2023.         if (!argcount(1))
  2024.         return 0;
  2025.         ip = (int_element_t*)make_element(interp_depthcue,1);
  2026.         ip->arg[0] = readint(0);
  2027.         return (element_t*)ip;
  2028.     case DISPLACEPOLYGON:
  2029.         if (!argcount(1))
  2030.         return 0;
  2031.         fp = (float_element_t*)make_element(interp_displacepolygon,1);
  2032.         fp->arg[0] = readfloat(0);
  2033.         return (element_t*)fp;
  2034.     case DOUBLEBUFFER:
  2035.         if (!argcount(0))
  2036.         return 0;
  2037.         return make_element(doublebuffer,0);
  2038.     case DRAW:
  2039.         if (!argcount(3))
  2040.         return 0;
  2041.         breakok = FALSE;
  2042.         fp = (float_element_t*)make_element(interp_draw,3);
  2043.         fx = readfloat(0);
  2044.         fy = readfloat(1);
  2045.         fz = readfloat(2);
  2046.         keepbounds(fx,fy,fz,1.0);
  2047.         fp->arg[0] = fx;
  2048.         fp->arg[1] = fy;
  2049.         fp->arg[2] = fz;
  2050.         return (element_t*)fp;
  2051.     case DRAWMODE:
  2052.         if (!argcount(1))
  2053.         return 0;
  2054.         ip = (int_element_t*)make_element(interp_drawmode,1);
  2055.         ip->arg[0] = readint(0);
  2056.         return (element_t*)ip;
  2057.     case ENDCLOSEDLINE:
  2058.         if (!argcount(0))
  2059.         return 0;
  2060.         breakok = TRUE;
  2061.         return make_element(endclosedline,0);
  2062.     case ENDGROUP:
  2063.         if (!argcount(0))
  2064.         return 0;
  2065.         breakok = TRUE;
  2066.         return make_element(interp_endgroup,0);
  2067.     case ENDLINE:
  2068.         if (!argcount(0))
  2069.         return 0;
  2070.         breakok = TRUE;
  2071.         return make_element(endline,0);
  2072.     case ENDPOINT:
  2073.         if (!argcount(0))
  2074.         return 0;
  2075.         breakok = TRUE;
  2076.         return make_element(endpoint,0);
  2077.     case ENDPOLYGON:
  2078.         if (!argcount(0))
  2079.         return 0;
  2080.         breakok = TRUE;
  2081.         return make_element(endpolygon,0);
  2082.     case ENDQSTRIP:
  2083.         if (!argcount(0))
  2084.         return 0;
  2085.         breakok = TRUE;
  2086.         return make_element(endqstrip,0);
  2087.     case ENDTMESH:
  2088.         if (!argcount(0))
  2089.         return 0;
  2090.         breakok = TRUE;
  2091.         return make_element(endtmesh,0);
  2092.     case FOGVERTEX:
  2093.         if (!minargcount(1))
  2094.         return 0;
  2095.         size = awkNF - 1;
  2096.         fp = (float_element_t*)make_element(interp_clipplane,size);
  2097.         fp->arg[0] = (float)readint(0);
  2098.         for (i=1; i<size; i++)
  2099.         fp->arg[i] = readfloat(i);
  2100.         return (element_t*)fp;
  2101.     case FRONTBUFFER:
  2102.         if (!argcount(1))
  2103.         return 0;
  2104.         ip = (int_element_t*)make_element(interp_frontbuffer,1);
  2105.         ip->arg[0] = readint(0);
  2106.         return (element_t*)ip;
  2107.     case FRONTFACE:
  2108.         if (!argcount(1))
  2109.         return 0;
  2110.         ip = (int_element_t*)make_element(interp_frontface,1);
  2111.         ip->arg[0] = readint(0);
  2112.         return (element_t*)ip;
  2113.     case GCONFIG:
  2114.         if (!argcount(0))
  2115.         return 0;
  2116.         return make_element(gconfig,0);
  2117.     case GLCOMPAT:
  2118.         if (!argcount(2))
  2119.         return 0;
  2120.         ip = (int_element_t*)make_element(interp_glcompat,2);
  2121.         ip->arg[0] = readint(0);
  2122.         ip->arg[1] = readint(1);
  2123.         return (element_t*)ip;
  2124.     case GROUPTYPE:
  2125.         if (!argcount(1))
  2126.         return 0;
  2127.         ip = (int_element_t*)make_element(interp_grouptype,1);
  2128.         ip->arg[0] = readint(0);
  2129.         return (element_t*)ip;
  2130.     case HOLLOWCOLOR:
  2131.         if (!argcount(1))
  2132.         return 0;
  2133.         ip = (int_element_t*)make_element(interp_hollowcolor,1);
  2134.         ip->arg[0] = readint(0);
  2135.         return (element_t*)ip;
  2136.     case HOLLOWWIDTH:
  2137.         if (!argcount(1))
  2138.         return 0;
  2139.         ip = (int_element_t*)make_element(interp_hollowwidth,1);
  2140.         ip->arg[0] = readint(0);
  2141.         return (element_t*)ip;
  2142.     case LINESMOOTH:
  2143.         if (!argcount(1))
  2144.         return 0;
  2145.         ip = (int_element_t*)make_element(interp_linesmooth,1);
  2146.         ip->arg[0] = readint(0);
  2147.         return (element_t*)ip;
  2148.     case LINEWIDTH:
  2149.         if (!argcount(1))
  2150.         return 0;
  2151.         ip = (int_element_t*)make_element(interp_linewidth,1);
  2152.         ip->arg[0] = readint(0);
  2153.         return (element_t*)ip;
  2154.     case LMBIND:
  2155.         if (!argcount(2))
  2156.         return 0;
  2157.         ip = (int_element_t*)make_element(interp_lmbind,2);
  2158.         ip->arg[0] = readint(0);
  2159.         ip->arg[1] = readint(1);
  2160.         return (element_t*)ip;
  2161.     case LMCOLOR:
  2162.         if (!argcount(1))
  2163.         return 0;
  2164.         ip = (int_element_t*)make_element(interp_lmcolor,1);
  2165.         ip->arg[0] = readint(0);
  2166.         return (element_t*)ip;
  2167.     case LMDEF:
  2168.         if (!minargcount(4))
  2169.         return 0;
  2170.         size = awkNF - 1;
  2171.         fp = (float_element_t*)make_element(interp_lmdef,size);
  2172.         fp->arg[0] = (float)readint(0);
  2173.         fp->arg[1] = (float)readint(1);
  2174.         fp->arg[2] = (float)readint(2);
  2175.         for (i=3; i<size; i++)
  2176.         fp->arg[i] = readfloat(i);
  2177.         return (element_t*)fp;
  2178.     case LOADMATRIX:
  2179.         if (!argcount(16))
  2180.         return 0;
  2181.         fp = (float_element_t*)make_element(loadmatrix,16);
  2182.         for (i=0; i<16; i++)
  2183.         fp->arg[i] = readfloat(i);
  2184.         return (element_t*)fp;
  2185.     case LOGICOP:
  2186.         if (!argcount(1))
  2187.         return 0;
  2188.         ip = (int_element_t*)make_element(interp_logicop,1);
  2189.         ip->arg[0] = readint(0);
  2190.         return (element_t*)ip;
  2191.     case LOOKAT:
  2192.         if (!argcount(7))
  2193.         return 0;
  2194.         fp = (float_element_t*)make_element(interp_lookat,7);
  2195.         for (i=0; i<7; i++)
  2196.         fp->arg[i] = readfloat(i);
  2197.         return (element_t*)fp;
  2198.     case LRECTWRITE:
  2199.         if (!argcount(5))
  2200.         return 0;
  2201.         ip = (int_element_t*)make_element(interp_lrectwrite,5);
  2202.         ip->arg[0] = readint(0);
  2203.         ip->arg[1] = readint(1);
  2204.         ip->arg[2] = readint(2);
  2205.         ip->arg[3] = readint(3);
  2206.         {
  2207.         char bigstring[100];
  2208.         unsigned long* imagepointer;
  2209.         unsigned long** ipnt;
  2210.         readstring(4,bigstring);
  2211.         imagepointer = (unsigned long*)
  2212.             awkGetPointer(ImagePointer,bigstring);
  2213.         ipnt = (unsigned long**) &(ip->arg[4]);
  2214.         if (imagepointer) {
  2215.             *ipnt = imagepointer;
  2216.         }
  2217.         else {
  2218.             imagepointer = readimagedata(bigstring);
  2219.             *ipnt = imagepointer;
  2220.             awkAddPointer(ImagePointer,bigstring,imagepointer);
  2221.         }
  2222.         }
  2223.         return (element_t*)ip;
  2224.     case LRGBRANGE:
  2225.         if (!argcount(8))
  2226.         return 0;
  2227.         ip = (int_element_t*)make_element(interp_lrgbrange,8);
  2228.         for (i=0; i<8; i++)
  2229.         ip->arg[i] = readint(i);
  2230.         return (element_t*)ip;
  2231.     case LSETDEPTH:
  2232.         if (!argcount(2))
  2233.         return 0;
  2234.         ip = (int_element_t*)make_element(interp_lsetdepth,2);
  2235.         ip->arg[0] = readint(0);
  2236.         ip->arg[1] = readint(1);
  2237.         return (element_t*)ip;
  2238.     case LSHADERANGE:
  2239.         if (!argcount(4))
  2240.         return 0;
  2241.         ip = (int_element_t*)make_element(interp_lshaderange,4);
  2242.         ip->arg[0] = readint(0);
  2243.         ip->arg[1] = readint(1);
  2244.         ip->arg[2] = readint(2);
  2245.         ip->arg[3] = readint(3);
  2246.         return (element_t*)ip;
  2247.     case LSREPEAT:
  2248.         if (!argcount(1))
  2249.         return 0;
  2250.         ip = (int_element_t*)make_element(interp_lsrepeat,1);
  2251.         ip->arg[0] = readint(0);
  2252.         return (element_t*)ip;
  2253.     case MAPCOLOR:
  2254.         ip = (int_element_t*)make_element(interp_mapcolor,4);
  2255.         ip->arg[0] = readint(0);
  2256.         ip->arg[1] = readint(1);
  2257.         ip->arg[2] = readint(2);
  2258.         ip->arg[3] = readint(3);
  2259.         return (element_t*)ip;
  2260.     case MMODE:
  2261.         if (!argcount(1))
  2262.         return 0;
  2263.         ip = (int_element_t*)make_element(interp_mmode,1);
  2264.         ip->arg[0] = readint(0);
  2265.         return (element_t*)ip;
  2266.     case MOVE:
  2267.         if (!argcount(3))
  2268.         return 0;
  2269.         breakok = FALSE;
  2270.         fp = (float_element_t*)make_element(interp_move,3);
  2271.         fx = readfloat(0);
  2272.         fy = readfloat(1);
  2273.         fz = readfloat(2);
  2274.         keepbounds(fx,fy,fz,1.0);
  2275.         fp->arg[0] = fx;
  2276.         fp->arg[1] = fy;
  2277.         fp->arg[2] = fz;
  2278.         return (element_t*)fp;
  2279.     case MULTMATRIX:
  2280.         if (!argcount(16))
  2281.         return 0;
  2282.         fp = (float_element_t*)make_element(multmatrix,16);
  2283.         for (i=0; i<16; i++)
  2284.         fp->arg[i] = readfloat(i);
  2285.         return (element_t*)fp;
  2286.     case MSWAPBUFFERS:
  2287.         if (!argcount(1))
  2288.         return 0;
  2289.         ip = (int_element_t*)make_element(interp_mswapbuffers,1);
  2290.         ip->arg[0] = readint(0);
  2291.         return (element_t*)ip;
  2292.     case N3F:
  2293.         if (!argcount(3))
  2294.         return 0;
  2295.         fp = (float_element_t*)make_element(n3f,3);
  2296.         fp->arg[0] = readfloat(0);
  2297.         fp->arg[1] = readfloat(1);
  2298.         fp->arg[2] = readfloat(2);
  2299.         return (element_t*)fp;
  2300.     case NMODE:
  2301.         if (!argcount(1))
  2302.         return 0;
  2303.         ip = (int_element_t*)make_element(interp_nmode,1);
  2304.         ip->arg[0] = readint(0);
  2305.         return (element_t*)ip;
  2306.     case ORTHO:
  2307.         if (!argcount(6))
  2308.         return 0;
  2309.         fp = (float_element_t*)make_element(interp_ortho,6);
  2310.         for (i=0; i<6; i++)
  2311.         fp->arg[i] = readfloat(i);
  2312.         return (element_t*)fp;
  2313.     case ORTHO2:
  2314.         if (!argcount(4))
  2315.         return 0;
  2316.         fp = (float_element_t*)make_element(interp_ortho2,4);
  2317.         for (i=0; i<4; i++)
  2318.         fp->arg[i] = readfloat(i);
  2319.         return (element_t*)fp;
  2320.     case OVERLAY:
  2321.         if (!argcount(1))
  2322.         return 0;
  2323.         ip = (int_element_t*)make_element(interp_overlay,1);
  2324.         ip->arg[0] = readint(0);
  2325.         return (element_t*)ip;
  2326.     case PCLOS:
  2327.         if (!argcount(0))
  2328.         return 0;
  2329.         ip = (int_element_t*)make_element(pclos,0);
  2330.         return (element_t*)ip;
  2331.     case PDR:
  2332.         if (!argcount(3))
  2333.         return 0;
  2334.         breakok = FALSE;
  2335.         fp = (float_element_t*)make_element(interp_pdr,3);
  2336.         fx = readfloat(0);
  2337.         fy = readfloat(1);
  2338.         fz = readfloat(2);
  2339.         keepbounds(fx,fy,fz,1.0);
  2340.         fp->arg[0] = fx;
  2341.         fp->arg[1] = fy;
  2342.         fp->arg[2] = fz;
  2343.         return (element_t*)fp;
  2344.     case PERSPECTIVE:
  2345.         if (!argcount(4))
  2346.         return 0;
  2347.         fp = (float_element_t*)make_element(interp_perspective,4);
  2348.         fp->arg[0] = (float)readint(0);
  2349.         fp->arg[1] = readfloat(1);
  2350.         fp->arg[2] = readfloat(2);
  2351.         fp->arg[3] = readfloat(3);
  2352.         return (element_t*)fp;
  2353.     case PIXMODE:
  2354.         if (!argcount(2))
  2355.         return 0;
  2356.         ip = (int_element_t*)make_element(interp_pixmode,2);
  2357.         ip->arg[0] = readint(0);
  2358.         ip->arg[1] = readint(1);
  2359.         return (element_t*)ip;
  2360.     case PMV:
  2361.         if (!argcount(3))
  2362.         return 0;
  2363.         breakok = FALSE;
  2364.         fp = (float_element_t*)make_element(interp_pmv,3);
  2365.         fx = readfloat(0);
  2366.         fy = readfloat(1);
  2367.         fz = readfloat(2);
  2368.         keepbounds(fx,fy,fz,1.0);
  2369.         fp->arg[0] = fx;
  2370.         fp->arg[1] = fy;
  2371.         fp->arg[2] = fz;
  2372.         return (element_t*)fp;
  2373.     case PNT:
  2374.         if (!argcount(3))
  2375.         return 0;
  2376.         fp = (float_element_t*)make_element(interp_pnt,3);
  2377.         fx = readfloat(0);
  2378.         fy = readfloat(1);
  2379.         fz = readfloat(2);
  2380.         keepbounds(fx,fy,fz,1.0);
  2381.         fp->arg[0] = fx;
  2382.         fp->arg[1] = fy;
  2383.         fp->arg[2] = fz;
  2384.         return (element_t*)fp;
  2385.     case PNTSIZE:
  2386.         if (!argcount(1))
  2387.         return 0;
  2388.         fp = (float_element_t*)make_element(interp_pntsize,1);
  2389.         fp->arg[0] = readfloat(0);
  2390.         return (element_t*)fp;
  2391.     case PNTSMOOTH:
  2392.         if (!argcount(1))
  2393.         return 0;
  2394.         ip = (int_element_t*)make_element(interp_pntsmooth,1);
  2395.         ip->arg[0] = readint(0);
  2396.         return (element_t*)ip;
  2397.     case POLARVIEW:
  2398.         if (!argcount(4))
  2399.         return 0;
  2400.         fp = (float_element_t*)make_element(interp_polarview,4);
  2401.         fp->arg[0] = readfloat(0);
  2402.         fp->arg[1] = (float)readint(1);
  2403.         fp->arg[2] = (float)readint(2);
  2404.         fp->arg[3] = (float)readint(3);
  2405.         return (element_t*)fp;
  2406.     case POLF:
  2407.         if (!minargcount(4))
  2408.         return 0;
  2409.         breakok = TRUE;
  2410.         size = awkNF - 1;
  2411.         fp = (float_element_t*)make_element(interp_polf,size);
  2412.         fp->arg[0] = (float)readint(0);
  2413.         for (i=1; i<size; i+=3) {
  2414.         fx = readfloat(i+0);
  2415.         fy = readfloat(i+1);
  2416.         fz = readfloat(i+2);
  2417.         keepbounds(fx,fy,fz,1.0);
  2418.         fp->arg[i+0] = fx;
  2419.         fp->arg[i+1] = fy;
  2420.         fp->arg[i+2] = fz;
  2421.         }
  2422.         return (element_t*)fp;
  2423.     case POLY:
  2424.         if (!minargcount(4))
  2425.         return 0;
  2426.         breakok = TRUE;
  2427.         size = awkNF - 1;
  2428.         fp = (float_element_t*)make_element(interp_poly,size);
  2429.         fp->arg[0] = (float)readint(0);
  2430.         for (i=1; i<size; i+=3) {
  2431.         fx = readfloat(i+0);
  2432.         fy = readfloat(i+1);
  2433.         fz = readfloat(i+2);
  2434.         keepbounds(fx,fy,fz,1.0);
  2435.         fp->arg[i+0] = fx;
  2436.         fp->arg[i+1] = fy;
  2437.         fp->arg[i+2] = fz;
  2438.         }
  2439.         return (element_t*)fp;
  2440.     case POLYMODE:
  2441.         if (!argcount(1))
  2442.         return 0;
  2443.         ip = (int_element_t*)make_element(interp_polymode,1);
  2444.         ip->arg[0] = readint(0);
  2445.         return (element_t*)ip;
  2446.     case POLYSMOOTH:
  2447.         if (!argcount(1))
  2448.         return 0;
  2449.         ip = (int_element_t*)make_element(interp_polysmooth,1);
  2450.         ip->arg[0] = readint(0);
  2451.         return (element_t*)ip;
  2452.     case POPMATRIX:
  2453.         if (!argcount(0))
  2454.         return 0;
  2455.         return make_element(popmatrix,0);
  2456.     case PUSHMATRIX:
  2457.         if (!argcount(0))
  2458.         return 0;
  2459.         return make_element(pushmatrix,0);
  2460.     case READSOURCE:
  2461.         if (!argcount(1))
  2462.         return 0;
  2463.         ip = (int_element_t*)make_element(interp_readsource,1);
  2464.         ip->arg[0] = readint(0);
  2465.         return (element_t*)ip;
  2466.     case RECT:
  2467.         if (!argcount(4))
  2468.         return 0;
  2469.         breakok = TRUE;
  2470.         fp = (float_element_t*)make_element(interp_rect,4);
  2471.         fx = readfloat(0);
  2472.         fy = readfloat(1);
  2473.         fx2 = readfloat(2);
  2474.         fy2 = readfloat(3);
  2475.         keepbounds(fx,fy,0.0,1.0);
  2476.         keepbounds(fx,fy2,0.0,1.0);
  2477.         keepbounds(fx2,fy,0.0,1.0);
  2478.         keepbounds(fx2,fy2,0.0,1.0);
  2479.         fp->arg[0] = fx;
  2480.         fp->arg[1] = fy;
  2481.         fp->arg[2] = fx2;
  2482.         fp->arg[3] = fy2;
  2483.         return (element_t*)fp;
  2484.     case RECTCOPY:
  2485.         if (!argcount(6))
  2486.         return 0;
  2487.         ip = (int_element_t*)make_element(interp_rectcopy,6);
  2488.         for (i=0; i<6; i++)
  2489.         ip->arg[i] = readint(i);
  2490.         return (element_t*)ip;
  2491.     case RECTF:
  2492.         if (!argcount(4))
  2493.         return 0;
  2494.         breakok = TRUE;
  2495.         fp = (float_element_t*)make_element(interp_rectf,4);
  2496.         fx = readfloat(0);
  2497.         fy = readfloat(1);
  2498.         fx2 = readfloat(2);
  2499.         fy2 = readfloat(3);
  2500.         keepbounds(fx,fy,0.0,1.0);
  2501.         keepbounds(fx,fy2,0.0,1.0);
  2502.         keepbounds(fx2,fy,0.0,1.0);
  2503.         keepbounds(fx2,fy2,0.0,1.0);
  2504.         fp->arg[0] = fx;
  2505.         fp->arg[1] = fy;
  2506.         fp->arg[2] = fx2;
  2507.         fp->arg[3] = fy2;
  2508.         return (element_t*)fp;
  2509.     case RECTZOOM:
  2510.         if (!argcount(2))
  2511.         return 0;
  2512.         fp = (float_element_t*)make_element(interp_rectzoom,2);
  2513.         fp->arg[0] = readfloat(0);
  2514.         fp->arg[1] = readfloat(1);
  2515.         return (element_t*)fp;
  2516.     case RGBCOLOR:
  2517.         if (!argcount(3))
  2518.         return 0;
  2519.         ip = (int_element_t*)make_element(interp_RGBcolor,3);
  2520.         ip->arg[0] = readint(0);
  2521.         ip->arg[1] = readint(1);
  2522.         ip->arg[2] = readint(2);
  2523.         return (element_t*)ip;
  2524.     case RGBMODE:
  2525.         if (!argcount(0))
  2526.         return 0;
  2527.         return make_element(RGBmode,0);
  2528.     case RGBWRITEMASK:
  2529.         if (!argcount(3))
  2530.         return 0;
  2531.         ip = (int_element_t*)make_element(interp_RGBwritemask,3);
  2532.         ip->arg[0] = readint(0);
  2533.         ip->arg[1] = readint(1);
  2534.         ip->arg[2] = readint(2);
  2535.         return (element_t*)ip;
  2536.     case ROT:
  2537.         if (!argcount(2))
  2538.         return 0;
  2539.         fp = (float_element_t*)make_element(interp_rot,2);
  2540.         fp->arg[0] = readfloat(0);
  2541.         fp->arg[1] = (float)readchar(1);
  2542.         return (element_t*)fp;
  2543.     case ROTATE:
  2544.         if (!argcount(2))
  2545.         return 0;
  2546.         ip = (int_element_t*)make_element(interp_rotate,2);
  2547.         ip->arg[0] = readint(0);
  2548.         ip->arg[1] = readchar(1);
  2549.         return (element_t*)ip;
  2550.     case SBOX:
  2551.         if (!argcount(4))
  2552.         return 0;
  2553.         breakok = TRUE;
  2554.         fp = (float_element_t*)make_element(interp_sbox,4);
  2555.         fx = readfloat(0);
  2556.         fy = readfloat(1);
  2557.         fx2 = readfloat(2);
  2558.         fy2 = readfloat(3);
  2559.         keepbounds(fx,fy,0.0,1.0);
  2560.         keepbounds(fx2,fy2,0.0,1.0);
  2561.         fp->arg[0] = fx;
  2562.         fp->arg[1] = fy;
  2563.         fp->arg[2] = fx2;
  2564.         fp->arg[3] = fy2;
  2565.         return (element_t*)fp;
  2566.     case SBOXF:
  2567.         if (!argcount(4))
  2568.         return 0;
  2569.         breakok = TRUE;
  2570.         fp = (float_element_t*)make_element(interp_sboxf,4);
  2571.         fx = readfloat(0);
  2572.         fy = readfloat(1);
  2573.         fx2 = readfloat(2);
  2574.         fy2 = readfloat(3);
  2575.         keepbounds(fx,fy,0.0,1.0);
  2576.         keepbounds(fx2,fy2,0.0,1.0);
  2577.         fp->arg[0] = fx;
  2578.         fp->arg[1] = fy;
  2579.         fp->arg[2] = fx2;
  2580.         fp->arg[3] = fy2;
  2581.         return (element_t*)fp;
  2582.     case SCALE:
  2583.         if (!argcount(3))
  2584.         return 0;
  2585.         fp = (float_element_t*)make_element(interp_scale,3);
  2586.         fp->arg[0] = readfloat(0);
  2587.         fp->arg[1] = readfloat(1);
  2588.         fp->arg[2] = readfloat(2);
  2589.         return (element_t*)fp;
  2590.     case SCLEAR:
  2591.         if (!argcount(1))
  2592.         return 0;
  2593.         ip = (int_element_t*)make_element(interp_sclear,1);
  2594.         ip->arg[0] = readint(0);
  2595.         return (element_t*)ip;
  2596.     case SCRBOX:
  2597.         if (!argcount(1))
  2598.         return 0;
  2599.         ip = (int_element_t*)make_element(interp_scrbox,1);
  2600.         ip->arg[0] = readint(0);
  2601.         return (element_t*)ip;
  2602.     case SCRMASK:
  2603.         if (!argcount(4))
  2604.         return 0;
  2605.         ip = (int_element_t*)make_element(interp_scrmask,4);
  2606.         ip->arg[0] = readint(0);
  2607.         ip->arg[1] = readint(1);
  2608.         ip->arg[2] = readint(2);
  2609.         ip->arg[3] = readint(3);
  2610.         return (element_t*)ip;
  2611.     case SCRSUBDIVIDE:
  2612.         if (!minargcount(1))
  2613.         return 0;
  2614.         size = awkNF - 1;
  2615.         fp = (float_element_t*)make_element(interp_scrsubdivide,size);
  2616.         fp->arg[0] = (float)readint(0);
  2617.         for (i=1; i<size; i++)
  2618.         fp->arg[i] = readfloat(i);
  2619.         return (element_t*)fp;
  2620.     case SETDEPTH:
  2621.         if (!argcount(2))
  2622.         return 0;
  2623.         ip = (int_element_t*)make_element(interp_lsetdepth,2);
  2624.         ip->arg[0] = readint(0);
  2625.         ip->arg[1] = readint(1);
  2626.         return (element_t*)ip;
  2627.     case SETLINESTYLE:
  2628.         if (!argcount(1))
  2629.         return 0;
  2630.         ip = (int_element_t*)make_element(interp_setlinestyle,1);
  2631.         ip->arg[0] = readint(0);
  2632.         return (element_t*)ip;
  2633.     case SETPATTERN:
  2634.         if (!argcount(1))
  2635.         return 0;
  2636.         ip = (int_element_t*)make_element(interp_setpattern,1);
  2637.         ip->arg[0] = readint(0);
  2638.         return (element_t*)ip;
  2639.     case SHADEMODEL:
  2640.         if (!argcount(1))
  2641.         return 0;
  2642.         ip = (int_element_t*)make_element(interp_shademodel,1);
  2643.         ip->arg[0] = readint(0);
  2644.         return (element_t*)ip;
  2645.     case SHADERANGE:
  2646.         if (!argcount(4))
  2647.         return 0;
  2648.         ip = (int_element_t*)make_element(interp_shaderange,4);
  2649.         ip->arg[0] = readint(0);
  2650.         ip->arg[1] = readint(1);
  2651.         ip->arg[2] = readint(2);
  2652.         ip->arg[3] = readint(3);
  2653.         return (element_t*)ip;
  2654.     case STENCIL:
  2655.         if (!argcount(7))
  2656.         return 0;
  2657.         ip = (int_element_t*)make_element(interp_stencil,7);
  2658.         ip->arg[0] = readint(0);
  2659.         ip->arg[1] = readint(1);
  2660.         ip->arg[2] = readint(2);
  2661.         ip->arg[3] = readint(3);
  2662.         ip->arg[4] = readint(4);
  2663.         ip->arg[5] = readint(5);
  2664.         ip->arg[6] = readint(6);
  2665.         return (element_t*)ip;
  2666.     case STENSIZE:
  2667.         if (!argcount(1))
  2668.         return 0;
  2669.         ip = (int_element_t*)make_element(interp_stensize,1);
  2670.         ip->arg[0] = readint(0);
  2671.         return (element_t*)ip;
  2672.     case SINGLEBUFFER:
  2673.         if (!argcount(0))
  2674.         return 0;
  2675.         return make_element(singlebuffer,0);
  2676.     case SUBPIXEL:
  2677.         if (!argcount(1))
  2678.         return 0;
  2679.         ip = (int_element_t*)make_element(interp_subpixel,1);
  2680.         ip->arg[0] = readint(0);
  2681.         return (element_t*)ip;
  2682.     case SWAPBUFFERS:
  2683.         if (!argcount(0))
  2684.         return 0;
  2685.         return make_element(swapbuffers,0);
  2686.     case SWAPTMESH:
  2687.         if (!argcount(0))
  2688.         return 0;
  2689.         return make_element(swaptmesh,0);
  2690.     case SWRITEMASK:
  2691.         if (!argcount(1))
  2692.         return 0;
  2693.         ip = (int_element_t*)make_element(interp_swritemask,1);
  2694.         ip->arg[0] = readint(0);
  2695.         return (element_t*)ip;
  2696.     case T2F:
  2697.         if (!argcount(2))
  2698.         return 0;
  2699.         fp = (float_element_t*)make_element(t2f,2);
  2700.         fp->arg[0] = readfloat(0);
  2701.         fp->arg[1] = readfloat(1);
  2702.         return (element_t*)fp;
  2703.     case TEVBIND:
  2704.         if (!argcount(2))
  2705.         return 0;
  2706.         ip = (int_element_t*)make_element(interp_tevbind,2);
  2707.         ip->arg[0] = readint(0);
  2708.         ip->arg[1] = readint(1);
  2709.         return (element_t*)ip;
  2710.     case TEVDEF:
  2711.         if (!minargcount(3))
  2712.         return 0;
  2713.         size = awkNF - 1;
  2714.         fp = (float_element_t*)make_element(interp_tevdef,size);
  2715.         fp->arg[0] = readint(0);
  2716.         fp->arg[1] = readint(1);
  2717.         for (i=2; i<size; i++)
  2718.         fp->arg[i] = readfloat(i);
  2719.         return (element_t*)fp;
  2720.     case TEXBIND:
  2721.         if (!argcount(2))
  2722.         return 0;
  2723.         ip = (int_element_t*)make_element(interp_texbind,2);
  2724.         ip->arg[0] = readint(0);
  2725.         ip->arg[1] = readint(1);
  2726.         return (element_t*)ip;
  2727.     case TEXDEF2D:
  2728.         if (!minargcount(7))
  2729.         return 0;
  2730.         size = awkNF - 1;
  2731.         fp = (float_element_t*)make_element(interp_texdef2d,size);
  2732.         fp->arg[0] = readint(0);
  2733.         fp->arg[1] = readint(1);
  2734.         fp->arg[2] = readint(2);
  2735.         fp->arg[3] = readint(3);
  2736.         {
  2737.         char bigstring[100];
  2738.         unsigned long* imagepointer;
  2739.         unsigned long** ipnt;
  2740.         readstring(4,bigstring);
  2741.         imagepointer = (unsigned long*)
  2742.             awkGetPointer(ImagePointer,bigstring);
  2743.         ipnt = (unsigned long**) &(fp->arg[4]);
  2744.         if (imagepointer) {
  2745.             *ipnt = imagepointer;
  2746.         }
  2747.         else {
  2748.             imagepointer = readimagedata(bigstring);
  2749.             *ipnt = imagepointer;
  2750.             awkAddPointer(ImagePointer,bigstring,imagepointer);
  2751.         }
  2752.         }
  2753.         fp->arg[5] = readint(5);
  2754.         for (i=6; i<size; i++)
  2755.         fp->arg[i] = readfloat(i);
  2756.         return (element_t*)fp;
  2757.     case POLYIMAGE:
  2758.         if (!argcount(3))
  2759.         return 0;
  2760.         breakok = TRUE;
  2761.         ip = (int_element_t*)make_element(interp_polyimage,3);
  2762.         ip->arg[0] = readint(0);
  2763.         ip->arg[1] = readint(1);
  2764.         {
  2765.         char bigstring[100];
  2766.         unsigned long* imagepointer;
  2767.         unsigned long** ipnt;
  2768.         readstring(2,bigstring);
  2769.         imagepointer = (unsigned long*)
  2770.             awkGetPointer(ImagePointer,bigstring);
  2771.         ipnt = (unsigned long**) &(ip->arg[2]);
  2772.         if (imagepointer) {
  2773.             *ipnt = imagepointer;
  2774.         }
  2775.         else {
  2776.             imagepointer = readimagedata(bigstring);
  2777.             *ipnt = imagepointer;
  2778.             awkAddPointer(ImagePointer,bigstring,imagepointer);
  2779.         }
  2780.         }
  2781.         keepbounds(0.0,0.0,0.0,1.0);
  2782.         keepbounds((float)ip->arg[0],(float)ip->arg[1],0.0,1.0);
  2783.         return (element_t*)ip;
  2784.     case TEXGEN:
  2785.         if (!minargcount(2))
  2786.         return 0;
  2787.         size = awkNF - 1;
  2788.         fp = (float_element_t*)make_element(interp_texgen,size);
  2789.         fp->arg[0] = (float)readint(0);
  2790.         fp->arg[1] = (float)readint(1);
  2791.         for (i=2; i<size; i++)
  2792.         fp->arg[i] = readfloat(i);
  2793.         return (element_t*)fp;
  2794.     case TRANSLATE:
  2795.         if (!argcount(3))
  2796.         return 0;
  2797.         fp = (float_element_t*)make_element(interp_translate,3);
  2798.         fp->arg[0] = readfloat(0);
  2799.         fp->arg[1] = readfloat(1);
  2800.         fp->arg[2] = readfloat(2);
  2801.         return (element_t*)fp;
  2802.     case UNDERLAY:
  2803.         if (!argcount(1))
  2804.         return 0;
  2805.         ip = (int_element_t*)make_element(interp_underlay,1);
  2806.         ip->arg[0] = readint(0);
  2807.         return (element_t*)ip;
  2808.     case V2F:
  2809.         if (!argcount(2))
  2810.         return 0;
  2811.         fp = (float_element_t*)make_element(v2f,2);
  2812.         fx = readfloat(0);
  2813.         fy = readfloat(1);
  2814.         keepbounds(fx,fy,0,1.0);
  2815.         fp->arg[0] = fx;
  2816.         fp->arg[1] = fy;
  2817.         return (element_t*)fp;
  2818.     case V3F:
  2819.         if (!argcount(3))
  2820.         return 0;
  2821.         fp = (float_element_t*)make_element(v3f,3);
  2822.         fx = readfloat(0);
  2823.         fy = readfloat(1);
  2824.         fz = readfloat(2);
  2825.         keepbounds(fx,fy,fz,1.0);
  2826.         fp->arg[0] = fx;
  2827.         fp->arg[1] = fy;
  2828.         fp->arg[2] = fz;
  2829.         return (element_t*)fp;
  2830.     case V4F:
  2831.         if (!argcount(4))
  2832.         return 0;
  2833.         fp = (float_element_t*)make_element(v4f,4);
  2834.         fx = readfloat(0);
  2835.         fy = readfloat(1);
  2836.         fz = readfloat(2);
  2837.         fw = readfloat(3);
  2838.         keepbounds(fx,fy,fz,fw);
  2839.         fp->arg[0] = fx;
  2840.         fp->arg[1] = fy;
  2841.         fp->arg[2] = fz;
  2842.         fp->arg[3] = fw;
  2843.         return (element_t*)fp;
  2844.     case VIEWPORT:
  2845.         if (!argcount(4))
  2846.         return 0;
  2847.         ip = (int_element_t*)make_element(interp_viewport,4);
  2848.         for (i=0; i<4; i++)
  2849.         ip->arg[i] = readint(i);
  2850.         return (element_t*)ip;
  2851.     case WINDOW:
  2852.         if (!argcount(6))
  2853.         return 0;
  2854.         fp = (float_element_t*)make_element(interp_window,6);
  2855.         for (i=0; i<6; i++)
  2856.         fp->arg[i] = readfloat(i);
  2857.         return (element_t*)fp;
  2858.     case WMPACK:
  2859.         if (!argcount(1))
  2860.         return 0;
  2861.         ip = (int_element_t*)make_element(interp_wmpack,1);
  2862.         ip->arg[0] = readint(0);
  2863.         return (element_t*)ip;
  2864.     case WRITEMASK:
  2865.         if (!argcount(1))
  2866.         return 0;
  2867.         ip = (int_element_t*)make_element(interp_writemask,1);
  2868.         ip->arg[0] = readint(0);
  2869.         return (element_t*)ip;
  2870.     case ZBUFFER:
  2871.         if (!argcount(1))
  2872.         return 0;
  2873.         ip = (int_element_t*)make_element(interp_zbuffer,1);
  2874.         ip->arg[0] = readint(0);
  2875.         return (element_t*)ip;
  2876.     case ZCLEAR:
  2877.         if (!argcount(0))
  2878.         return 0;
  2879.         return make_element(zclear,0);
  2880.     case ZDRAW:
  2881.         if (!argcount(1))
  2882.         return 0;
  2883.         ip = (int_element_t*)make_element(interp_zdraw,1);
  2884.         ip->arg[0] = readint(0);
  2885.         return (element_t*)ip;
  2886.     case ZFUNCTION:
  2887.         if (!argcount(1))
  2888.         return 0;
  2889.         ip = (int_element_t*)make_element(interp_zfunction,1);
  2890.         ip->arg[0] = readint(0);
  2891.         return (element_t*)ip;
  2892.     case ZSOURCE:
  2893.         if (!argcount(1))
  2894.         return 0;
  2895.         ip = (int_element_t*)make_element(interp_zsource,1);
  2896.         ip->arg[0] = readint(0);
  2897.         return (element_t*)ip;
  2898.     case ZWRITEMASK:
  2899.         if (!argcount(1))
  2900.         return 0;
  2901.         ip = (int_element_t*)make_element(interp_zwritemask,1);
  2902.         ip->arg[0] = readint(0);
  2903.         return (element_t*)ip;
  2904.     default:
  2905.         fprintf(stderr,"%s line %d: command %s not implemented, ignored\n",
  2906.         awkFILENAME,awkNL,awkARG[1]);
  2907.         return 0;
  2908.     }
  2909. }
  2910.  
  2911. static char* endname(char* s) {
  2912.     /* return pointer to file name after last "/" */
  2913.     register i;
  2914.     for (i=strlen(s)-1; i>=0; i--)
  2915.     if (s[i] == '/')
  2916.         return &s[i+1];
  2917.     return s;
  2918. }
  2919.  
  2920. /*
  2921.  *    Open the named file and build an interp data structure
  2922.  */
  2923.  
  2924. element_t* getinterpobj(char* filename) {
  2925.     element_t* base;
  2926.     register element_t* sp;
  2927.     element_t* newsp;
  2928.  
  2929.     awkFile(filename);
  2930.     base = 0;
  2931.     vcount = 0;
  2932.     while (awkNextRecord()) {
  2933.     if (newsp = interpline()) {
  2934.         if (base == 0) {
  2935.         base = sp = newsp;
  2936.         } else {
  2937.         sp->next = newsp;
  2938.         sp = newsp;
  2939.         }
  2940.     }
  2941.     if ((vcount > MAXVCOUNT) && breakok) {
  2942.         vcount = 0;
  2943.         newsp = make_element(interp_breakcheck,0);
  2944.         sp->next = newsp;
  2945.         sp = newsp;
  2946.     }
  2947.     }
  2948.     awkAddPointer(FilePointers,endname(filename),(char*)base);
  2949.     return base;
  2950. }
  2951.  
  2952. /*
  2953.  *    Draw an interp data structure
  2954.  */
  2955.  
  2956. void drawinterpobj(element_t* obj) {
  2957.     register element_t* sp;
  2958.  
  2959.     sp = obj;
  2960.     while (sp) {
  2961.     sp->func((float*)sp+NONDATASIZE);
  2962.     sp = sp->next;
  2963.     }
  2964. }
  2965.  
  2966. void setbreakfunction(void(*func)()) {
  2967.     breakfunction = func;
  2968. }
  2969.  
  2970. /*
  2971.  * Image file functions
  2972.  *
  2973.  */
  2974. #include <gl/image.h>
  2975.  
  2976. void sizeofimage(char* name, int* xsize, int* ysize) {
  2977.     IMAGE* image;
  2978.  
  2979.     image = iopen(name,"r");
  2980.     if(!image) {
  2981.     fprintf(stderr,"sizeofimage: can't open image file\n");
  2982.     exit(1);
  2983.     }
  2984.     *xsize = image->xsize;
  2985.     *ysize = image->ysize;
  2986.     iclose(image);
  2987. }
  2988.  
  2989. static void rgbtocpack(unsigned short* r,unsigned short* g,unsigned short* b,unsigned long* l,int n) {
  2990.     while(n--) 
  2991.         *l++ = *r++ | ((*g++)<<8) | ((*b++)<<16) | 0xff000000;
  2992. }
  2993.  
  2994. static void cpacktorgba(unsigned long* l,unsigned short* r,unsigned short* g,unsigned short* b,unsigned short* a,int n) {
  2995.     long val;
  2996.  
  2997.     while(n--) {
  2998.         val = *l++;
  2999.     *r++ = val & 0xff;
  3000.     val >>= 8;
  3001.     *g++ = val & 0xff;
  3002.     val >>= 8;
  3003.     *b++ = val & 0xff;
  3004.     val >>= 8;
  3005.     *a++ = val & 0xff;
  3006.     }
  3007. }
  3008.  
  3009. unsigned long *readimagedata(char* name) {
  3010.     unsigned long* base;
  3011.     unsigned long* lptr;
  3012.     unsigned short* rbuf;
  3013.     unsigned short* gbuf;
  3014.     unsigned short* bbuf;
  3015.     IMAGE* image;
  3016.     int y;
  3017.  
  3018.     image = iopen(name,"r");
  3019.     if(!image) {
  3020.     fprintf(stderr,"readimagedata: can't open image file\n");
  3021.     exit(1);
  3022.     }
  3023.     base = (unsigned long *)malloc(image->xsize*image->ysize*sizeof(long));
  3024.     rbuf = (unsigned short *)malloc(image->xsize*sizeof(short));
  3025.     gbuf = (unsigned short *)malloc(image->xsize*sizeof(short));
  3026.     bbuf = (unsigned short *)malloc(image->xsize*sizeof(short));
  3027.     if(!base || !rbuf || !gbuf || !bbuf) {
  3028.     fprintf(stderr,"readimagedata: can't malloc enough memory\n");
  3029.     exit(1);
  3030.     }
  3031.     lptr = base;
  3032.     for(y=0; y<image->ysize; y++) {
  3033.     if(image->zsize>=3) {
  3034.         getrow(image,rbuf,y,0);
  3035.         getrow(image,gbuf,y,1);
  3036.         getrow(image,bbuf,y,2);
  3037.         rgbtocpack(rbuf,gbuf,bbuf,lptr,image->xsize);
  3038.         lptr += image->xsize;
  3039.     } else {
  3040.         getrow(image,rbuf,y,0);
  3041.         rgbtocpack(rbuf,rbuf,rbuf,lptr,image->xsize);
  3042.         lptr += image->xsize;
  3043.     }
  3044.     }
  3045.     iclose(image);
  3046.     free(rbuf);
  3047.     free(gbuf);
  3048.     free(bbuf);
  3049.     return base;
  3050. }
  3051.  
  3052. void writeimagedata(char* name,unsigned long* lbuf,int xsize,int ysize) {
  3053.     int y;
  3054.     IMAGE* oimage;
  3055.     unsigned short rbuf[1280];
  3056.     unsigned short gbuf[1280];
  3057.     unsigned short bbuf[1280];
  3058.     unsigned short abuf[1280];
  3059.  
  3060.     oimage = iopen(name,"w",RLE(1),3,xsize,ysize,4);
  3061.     if(!oimage) {
  3062.     fprintf(stderr,"lbuftoimg: can't open output file\n");
  3063.     exit(1);
  3064.     }
  3065.     for(y=0; y<ysize; y++) {
  3066.     cpacktorgba(lbuf,rbuf,gbuf,bbuf,abuf,xsize);
  3067.         putrow(oimage,rbuf,y,0);
  3068.         putrow(oimage,gbuf,y,1);
  3069.         putrow(oimage,bbuf,y,2);
  3070.         putrow(oimage,abuf,y,3);
  3071.     lbuf += xsize;
  3072.     }
  3073.     iclose(oimage);
  3074. }
  3075.